1、类和struct的区别

　　用class和struct关键字定义类的唯一差别在于默认访问权限：默认情况下，struct的成员为public（因此可以省略public关键字），而class的成员为private.

　　2、在C++中

　　每当函数返回时，都会清理栈。局部变量和函数参数存放在栈中。

　　只有到程序结束时候才会清理堆（java中自动清理），所以使用完堆内存时，程序员需要负责将其释放。如果在函数中预留堆中的内存，在函数返回后，该内存仍可用。当使用new关键字时候，程序会返回一个地址，因此只能用指针类型接收。注意用完之后要手动delete掉。

　　3、导致内存泄露的另一种情形是，没有释放指针指向的内存就直接给它重新赋值（重新new）

　　4、Teacher是一个类，

　　Teachert（name）；//在栈中创建了一个对象

　　Teacher *t = new Teacher （name）；//在堆中创建了一个对象

　　对于在栈中创建的Teacher对象，使用句点运算符（。）来访问其成员数据和成员函数；要访问对中的Teacher对象，必须对指针解引，并对指针指向的对象使用句点运算符。如（*t）。XXX.鉴于比较繁琐，c++提供一种指向运算符（->），可以直接写为t->XXX

　　5、

　　具体地说如果出现以下几种情况，程序就会执行析构函数：

　　①如果在一个函数中定义了一个对象（它是自动局部对象），当这个函数被调用结束时，对象应该释放，在对象释放前自动执行析构函数。

　　②static局部对象在函数调用结束时对象并不释放，因此也不调用析构函数，只在main函数结束或调用exit函数结束程序时，才调用static局部对象的析构函数。

　　③如果定义了一个全局对象，则在程序的流程离开其作用域时（如main函数结束或调用exit函数） 时，调用该全局对象的析构函数。

　　④如果用new运算符动态地建立了一个对象，当用delete运算符释放该对象时，先调用该对象的析构函数。

　　6、c++中this指针，用->来指向对象。无需为创建和删除this指针操心，编译器负责这项工作。

　　7、const指针

　　const int * pOne;//pOne是指向整型常量的指针，不能修改指向的值

　　int * const pTwo ;//pTwo是指向整型的常量指针，不能修改指针的指向。

　　const int * const pThree; //pThree是一个指向整型常量的常量指针。

　　8、创建引用时，使用另一对象的名称来初始化它，对引用执行的任何操作实际上针对的就是目标。引用即对象的别名，在内存中没有地址，也不占用空间，引用一旦初始化就不能修改。

　　9、c++中按值传递和按引用传递

　　按值传递：安全，备份的修改不会更改原值

　　按引用传递：引用不创建备份，效率高，但会改变原值

　　10、不要返回不在作用域内的引用。引用始终是一个实际存在对象的别名，如果它指向的是空对像，那么程序是非法的。

　　11、不能对引用进行delete,因此函数的返回值如果为堆对象，且让引用接收，那么就无法回收对象。这样只能将引用再赋给指针来delete.

　　12、可以重载构造函数，但不能重载析构函数。析构函数的签名总是这样：名称为类名加~,且不接受任何参数。

　　13、一种特殊的写法，构造函数初始化默认参数（红色部分）：

　　#include<iostream>

　　class Test

　　{

　　private :

　　int a;

　　int b;

　　public:

　　Test（）：

　　a（1），b（2）

　　{

　　}

　　Test（int a,int b）

　　{

　　this->a=a;

　　this->b=b;

　　}

　　int getA（）

　　{

　　return this->a;

　　}

　　int getB（）

　　{

　　return this->b;

　　}

　　};

　　14、拷贝构造函数

　　所有的拷贝构造函数都接受一个参数：指向类的引用。最好将该引用声明为常量，因为拷贝构造函数不能修改传入的对象。

　　15、不能对非NULL的指针进行delete,会报错。

　　16、如果未提供自己的拷贝构造函数，则C++提供一个默认拷贝构造函数，就像没有提供构造函数时，提供默认构造函数一样。

　　若用户没有定义拷贝构造函数，则编译器自动添加默认拷贝构造函数，称为浅拷贝。它只能完成基本类型数据类型（如int型变量）的拷贝，若类中有动态数组等数据类型， 浅拷贝就会出问题。即是说，浅拷贝有潜在危险（当类的数据成员都是基本类型数据类型时，它是安全的）。因此，在任何情况下，用户自定义拷贝构造函数是可取的。

　　出现指针成员变量的类中一定要自己写拷贝构造函数

　　17、成员方法加const表示该方法不会修改类成员。以下会报错：

　　void alterB（） const

　　{

　　this -> b = this -> b + 1;

　　}

　　18、运算符重载的格式如下

　　returnType operatorsymbol （parameter list）

　　{

　　}

　　//如对类Count的++（前缀）的重载

　　Count& operator++ （）

　　{

　　++value;

　　return *this;

　　}

　　//后缀++

　　Count operator++ （int）

　　{

　　Count tmp （*this）；

　　++value;

　　return tmp;

　　}

　　//加法运算符+

　　Count operator+ （Count& c）

　　{

　　return Count（this->value+c.value）；

　　}

　　main（）

　　{

　　Count c1,c2,c3;

　　c3=c1+c2;//这句话其实理解为c3=c1.operator+ （c2）；即成员函数调用

　　}

　　19、复制运算符

　　例如：

　　Count c1（1）；

　　Count c2（2）；

　　c1 = c2;//此处不会调用拷贝构造函数，因为c1已经存在。

　　上述赋值语句处会调用类中提供的默认赋值运算符。类中不仅提供了默认构造函数，默认析构函数，默认拷贝构造函数，还提供了默认复制运算符。

　　默认复制运算符与默认拷贝构造都有浅复制和深复制，浅复制只复制成员，导致两个对象执行同一个堆中区域。深复制则会分配内存。

　　可以重写复制运算符。假设类Count中有一个名为value的int指针

　　Count operator= （const Count& t）

　　{

　　if（this==t）

　　return this;

　　delete this -> value;

　　value = new int ;

　　*value = t.getValue（）；

　　return *this;

　　}

　　20、转换运算符

　　（1）内置类型变量赋值给一个用户定义类型对象

　　int i = 0;

　　Count t = i;

　　只需要在Count类中提供一个带int 参数的构造方法即可

　　（2）用户定义类型对象赋值给内置类变量

　　Count t （2） ;

　　int i = t;

　　需要在Count类中指定转换运算符，如下（下划线部分）：

　　class Count

　　{

　　public:

　　Count（int value）{this->value=value;}

　　operator unsigned int（）{return value;}

　　private:

　　int value;

　　}