记录，待总结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和前一篇文章，这个结果是很好理解的