字节:

Short:2  int:4  long:4  long long:8  float:4  double:8  char:1  bool:1  指针:4

3e2=3x102

看某字符的ASCII码:(int)ch;

可以直接给字符赋ASCII码:char ch=97;

C++是编译性语言，编译后生成.exe可执行文件

有:

代码区:只读、共享、存放CPU执行的二进制指令

全局区:存全局变量、静态变量、常量

常量区:存const修饰的常量

栈:存局部变量、形参

堆:存数组、对象

JAVA是解释性语言，编译后生成.class文件，可在多系统(Windows，Mac，Linux等)执行(跨平台)

有:

堆:存数组、对象

栈:局部变量、形参

方法区:常量池(存常量、字符串)、类加载信息

构造函数的初始化列表是专门用来初始化成员对象的

Date d与Date * p=new Date没有括号（若有默认为函数声明），有参数时调用构造函数才有括号

explicit关键字用来防止类构造函数的隐式自动转换

此时

class CxString  // 使用关键字explicit的类声明， 显示转换 

{ 

int _size; 

    explicit CxString(int size) 

    { 

        _size = size; 

    } 

}

CxString string2 = 10; CxString string6 = ‘c’;就不行了因为发生不了隐式转换

Base *pTest2 = new Derived(); //Base类的指针（多态实现：父类指针或引用指向子类对象）

    pTest2->DoSomething();

delete pTest2;

为了防止仅调用Base的析构而不调用Derived的析构造成内存泄漏，故Base类的析构函数要用virtual修饰

写文件:创建ofstream对象 open close 对象<< write(const char * buffer，int len) 字符指针buffer指向内存中一段存储空间。len是读写的字节数

读文件：创建ifstream对象 open close 对象>> read(char *buffer，int len) 字符指针buffer指向内存中一段存储空间。len是读写的字节数

is_open()：是否成功打开，返回布尔值

memset()函数原型是extern void *memset(void *buffer， int c， int count) 

清空数组： memset(buffer， 0， sizeof(buffer))

内联函数不能声明指针或外部类

引用作参数:

1.防止对象所占空间太大而调用复制构造函数

2.可以直接对该对象进行操作

cin>>get(数组名，大小，(结束符)): 若无结束语，遇到回车或达到(大小-1)则停止读取。

cin>>get():其实就是C语言里的getchar()读取一个字符

cin>>getline(数组名，大小，(结束符)):若无结束语，遇到回车或达到(大小-1)则停止读取。

getline(cin，字符串名，(结束符)):输入字符串，遇到结束符则结束。

以上结束符默认为enter，遇到结束符时剩余字符会停留在输入缓冲区，且结束符丢弃

重载强制类型转换:operator int()

{

return n;

}

模板中

typename C::const_iterator it(container.begin())：typename用于声明C::const_iterator是类型名而不是一个变量

template

class CMyistream_iterator

{

private:

       T value;

       istream ∈//使用引用的目的是减少开销，避免调用构造函数等等

public:

       CMyistream_iterator(istream &_in):in(_in) {//此处采用引用接受的目的是保证没有复制构造函数调用

              in >> value;//读入第一个数

       }

       T operator *() {

              return this->value;

       }

       void operator++(int) {

              in >> value;//读入后续的数

       }

};

.   ::   ?:   .*   sizeof不可重载

重载输出运算符:friend ostream& operator<<(ostream& out， Point& p) {

              out << p.x << "，" << p.y;

              return out;

       }

普通函数参数为函数时：可以

void fun(int fun2(~)):~依据需求填写，可以不写变量名

void fun(int (*fun2)(~)) 函数体内直接fun2(~)即可，*无影响，当成附加的东西即可

若为模板函数则

Template

Void fun(T fun2){

fun2(~):~依据需求填即可

}

对象数组初始化：{{}，{}，{}，{}~}——{}中的参数调用该类对应的构造函数

自定义二维数组构造器:

Int **p;

Array2(int a， int b) {

        m = a;

        n = b;

        p = new int* [m];

        for (int i = 0; i < m; i++) {

            p[i] = new int[n];

        }

    }

   重载[]:

 int*& operator[](int i) {

        return p[i];

    }

static_cast<类型>(变量):类型转换

类成员变量所占空间对齐

class Person {

public:

       Person operator+(const Person& p) {

              Person temp;

              temp.m_A = this->m_A + p.m_A;

              temp.m_B = this->m_B + p.m_B;//参数对象也可直接访问私有成员

              return temp;

       }

private:

       int m_A;

       int m_B;

};

Sample a=b调用拷贝构造函数

Sample a；

a=b指向同一对象，地址复制

常函数不可更改本类成员变量

// 第一个const表示返回值是个常量，用来防止 (p1+p2)=Point(10，20); 这种赋值

       // 括号内第二个const表示传入的参数可以接收const也可以接收非const

       // 第三个const表示常量可以调用该函数     

       const Point operator+(const Point &point) const {

              return Point(m_x + point.m_x， m_y + point.m_y);

       }

• Point p1 = (10， 20);

       Point p2 = (20， 30);

      (p1 + p2) = Point(40， 50); // 如果不加第1个const，则这里不会报错(应当让常量不能被赋值)

• Point p1 = (10， 20);

        const Point p2 = (20， 30);

        Point p3 = p1 + p2; // 不加第2个const，这里会报错，因为p2是常数

// 注意，这里p1是变量，p2是常量，由于重载了“+”

// 上一句代码等同于 p1.operator+(p2);

// 将p2视为了参数，即将常量视为参数。

(应当让常量也可以参与运算)

• const Point p1 = (10， 20);

        Point p2 = (20， 30);

        Point p3 = p1 + p2; // 不加第3个const，这里会报错，因为p1是常数

// 注意，这里p1是常量，p2是变量，由于重载了“+”

// 上一句代码等同于 p1.operator+(p2);

// 由p1调用的operator+函数，因此调用该函数的是个常数。

(让常量可以调用函数)

Point& operator+=(const Point &point) { // 返回值要注意

       this->m_x += point.m_x;

       this->m_y += point.m_y;·

       return *this;

}(p+=p1，p1可以是常量，p为变量)

Point& operator++() {} // 默认代表重载++a(a为变量)

const Point operator++(int) {} // 传入参数写int代表a++，固定格式。不能返回局部变量的引用

返回值为引用时，不调用复制构造函数

Static成员需要类外初始化

#include

atof(字符数组.c_str()):返回该字符串对应的double值，类似于java中的Double.parseDouble(字符串)

atoi(字符数组.c_str()):返回该字符串对应的int值，类似于java中的Integer.parseInt(字符串)

gcvt(double值，8(精度)，字符数组):取double值8的精度存到字符数组中，类似于java中的double值+“ ”

itoa(int值，字符数组，10(进制)):取int值以10进制存到字符数组中，类似于java中的int值+“ ”

静态成员变量需要在类外初始化；

静态函数只能调用静态东西

常函数和普通函数啥都能调用

常对象只能调用静态成员函数和常成员函数

普通对象和静态对象啥函数都能调用

int *a[5]:数组名是a，每个元素为指针类型

int (*a)[5]:数组名是a，每个元素是数组类型

子类可以调用本类对象继承来的保护性成员，但不能调用父类对象的该保护成员

Son son

son.Father::m:继承中有同名属性想访问父类的属性时

virtual void fun()=0是纯虚函数，使其子类可以重写

当有virtual修饰类时，多继承时该类指向同一块区域，不需要限定访问权限（不需要d::B.a，直接d.a），解决二义性。

C语言独有:

getchar()读取一个字符

gets()读取字符串

Char *a=“abc”;

十进制输出:%d

八进制输出:%o

十六进制输出:%x

字符串输出:%s

字符输出:%c

浮点形式输出:%f

C/C++中的strcpy()，strcat()，strlen()，strcmp()都是操控字符数组的

闰年二月29天，平年二月28天

当一个cin对象作为条件选择、循环等的控制表达式时，输入Ctrl+Z可终止循环（cin的返回值依然是cin对象）

拷贝构造函数三种调用情况:

• 用对象初始化另一对象
• 对象做参数
• 返回局部变量

Person p2=Person(p1);

Person p3=p1;

Person p4(p1);

当指针属性在堆中开辟空间，就自己提供拷贝构造函数，否则系统提供的默认复制构造函数是浅拷贝，会带来重复释放堆区的问题。

浅拷贝只是对指针的拷贝，拷贝后两个指针指向同一个内存空间，深拷贝不但对指针进行拷贝，而且对指针指向的内容进行拷贝，经深拷贝后的指针是指向两个不同地址的指针。

成员函数用const修饰后

void show () const {

  this->m=100;//若属性m有mutable修饰则可以更改，否则不行

}

查看运行类型:

C++:typeid(对象).name()

JAVA:对象.getclass().simplename()

分文件模板放在.hpp文件中

cpp中引入该头文件

string类初始化:

• const char* str=”hello”;
• string str(10，’a’):10个a构成
• string str=”hello”;
• string str;

str.assign(“hello”)

• string str;

str.assign(5，’x’)

string类方法

• +
• append
• find():返回下标
• rfind():返回最后一个下标
• replace(1，3，“abc”):将从1始3个字符换成abc
• compare():若相等返回0
• size():字符串长度
• at、[]可访问
• insert(num，”abc”):在num处插入abc
• erase(1，3):删除从1始3个字符
• substr(1，3):从1始截取3个字符

JAVA:ArrayList自动扩容  10  *1.5

         Vector自动扩容    10  *2

C++:手动扩容

模板实现具体化，前缀+template<>即可

template<> bool myCompare(Person& p1， Person& p2)

{

if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)

{

        return true;

}

else

{

       return false;

}

}

Vector初始化:

• vectorv2(v1.begin()，v1.end())
• vectorv(10，100):10个100
• vectorv3(v1)

函数对象即仿函数是重载了()的类

若返回的是bool类型，则该仿函数也叫谓词(一个参数就一元谓词，两个参数就二元谓词)

List不可跳跃访问(即不可it=it+1;但可it++)

cout<< a(3， 4) or  A()(3，4);//可以直接通过类对象（）调用重载函数

for_each(a.begin()， a.end()， A() or a);//做仿函数不需要写参数，普通函数可以直接写函数名

内建仿函数:

• plus
• minus
• multiplies
• divides
• modulus:取模
• negate:取反
• greater
• greater_equal
• less
• less_equal
• equal_to
• not_equal_to
• logical_and
• logical_or
• logical_not

STL算法:

遍历:

• for_each(beg，end，fun)
• transform(beg1，end1，beg2，fun): 搬运容器到另一个容器中

查找:

• find(beg，end，value):返回迭代器
• find_if(beg，end，fun):按条件找
• adjacent_find(beg，end):找相邻重复元素的第一个的迭代器
• binary_search(beg，end，value):找到返回true
• count(beg，end，value):统计个数
• count_if(beg，end，fun):根据条件统计个数
• lower_bound(beg，end，value):用二分查找的方式查找第一个>=value的数的指针
• upper_bound(beg，end，value):用二分查找的方式查找第一个>value的数的指针

排序:

• sort(beg，end，fun)
• random_shuffle(beg，end):随机排序
• merge(beg1，end1，beg2，end2，destination):合并两有序容器中的元素到新容器
• reverse(beg，end):反转

拷贝、替换:

• copy(beg，end，destination)
• replace(beg，end.old，new)
• replace_if(beg，end，fun，new)
• swap(container1，container2)

算数生成(包含numeric):

• accumulate(beg，end，value)
• fill(beg，end，value):填充

集合:

• set_intersection(beg1，end1，beg2，end2，destination):

1. 两集合元素有序
2. 目标容器指定大小为min(v1，v
3. 返回值是交集最后一个元素的迭代器

• set_union(beg1，end1，beg2，end2，destination)

1. 两集合元素有序
2. 目标容器指定大小为size(v1)+size(v
3. 返回指是并集最后一个元素的迭代器

• set_difference(beg1，end1，beg2，end2，destination)

1. 两集合元素有序
2. 目标容器指定大小为max(v1，v2)
3. 返回值是差集最后一个元素的迭代器