记录，待总结4

1.delete运算符只能删除堆中的空间，删除栈中的空间会导致出错
例1：int main() { A a; A *p = new A; A *q = &a; delete p;//正确，因为p指向堆中的未命名空间 delete q;//错误，因为q指向栈中的空间 return 0; }
2.关于强制类型转换
例2：class A { int x; public: A(int i):x(i){cout<<"construct "<<this<<endl;} A(const A& a){x = a.x;cout<<"copy "<<this<<endl;} ~A(){cout<<"delete "<<this<<endl;} void operator=(const A& a){x = a.x;cout<<"= "<<this<<endl;} void get(){cout<<x<<endl;} void set(int i){x = i;} }; int main() { A a(99), b(35); a.get(); a = 1000; //隐式的强制类型转换 + 赋值 a.get(); a = A(2); //显式的强制类型转换 + 赋值 a.get(); a = b; //赋值 a.get(); return 0; }

输出：
construct     0012FF38     //a的构造
construct     0012FF34     //b的构造
99
construct     0012FF30     //临时对象的构造
=     0012FF38             //赋值
delete     0012FF30        //临时对象的析构
1000
construct     0012FF2C     //临时对象的构造
=     0012FF38             //赋值
delete     0012FF2C        //临时对象的析构
2
=     0012FF38             //赋值
35
delete     0012FF34        //
delete     0012FF38        //
解释：不管是显示类型转换还是隐式类型转换，都有以下一些共同点：
1）先构造一个临时对象，把临时对象赋值给目标，然后析构临时对象
2）由于要构造一个临时对象，必须要有只带一个参数的构造函数
3）由于要用到赋值函数，当类中有指针成员时，要定义自己的复制控制函数

 

3.前置自加与后置自加
例3：

class A { int x; public: //前置自加 const A& operator++() { ++x; return *this; } //后置自加 const A operator++(int o) { A temp(*this); ++x; return temp; } };

解释：
1）前置自加按引用返回。
后置自加按值返回，且返回的是临时对象。
2）后置自加中的参数没有实际意义，只是为了区分前置
3）很显然前置自加效率更高，尽量用前置

 

4.这是对例3的一个应该举例
例4：

class A { int x; public: A(int i):x(i){cout<<"construct "<<this<<endl;} A(const A& a){x = a.x;cout<<"copy "<<this<<endl;} ~A(){cout<<"delete "<<this<<endl;} int get(){return x;} void set(int i){x = i;} //前置自加 const A& operator++() { ++x; return *this; } //后置自加 const A operator++(int o) { A temp(*this); ++x; return temp; } }; int main() { A a(1); cout<<a.get()<<endl; A b = ++a; cout<<b.get()<<endl; cout<<a.get()<<endl; b = a++; cout<<b.get()<<endl; cout<<a.get()<<endl; return 0; }

输出：

construct     0012FF38
1
copy     0012FF34
2
2
copy     0012FEB8
copy     0012FF30
delete     0012FEB8
delete     0012FF30
2
3
delete     0012FF34
delete     0012FF38
解释：如果看懂了例3和前一篇文章，这个结果是很好理解的