拷贝构造函数/重载赋值运算符

拷贝构造函数被调用的场合：（两种表达方式，说的都是一个意思，都摆上来，可能会更容易理解吧。PS：从两个地方看到的）

• 通过使用另一个同类型的对象来初始化新创建的对象。

• 复制对象把它作为参数传递给函数。

• 复制对象，并从函数返回这个对象。

一个对象以值传递的方式传入函数体 
一个对象以值传递的方式从函数返回 
一个对象需要通过另外一个对象进行初始化。

深拷贝和浅拷贝：

如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝；

反之，没有重新分配资源，就是浅拷贝。

【详解1】、【详解2】

下面是我做的测试：

#include <iostream>  
using namespace std; 

class CExample   
{  
private:  
 	int a;  
	int c;
  
public:  
 //构造函数  
 CExample(int b)  
 {   
	  a = b;  
	  c = 1021;
	  cout<<"creat: "<<a<<endl;  
 }  
  
 //拷贝构造  
 CExample(const CExample& C)  
 {  
	  a = C.a;  
	  cout<<"copy"<<endl;  
 }  
   
 //析构函数  
 ~CExample()  
 {  
  	cout<< "delete: "<<a<<endl;  
 }  
  
void Xiugai(int d)
{
	c = d ;
}
	
 void Show ()  
 {  
       cout<<a<<endl;
	   cout<<c<<'\n'<<endl;
 }  
};  

int main()  
{  
 	CExample test(1);
	test.Show();
	
	CExample A(5);

	A.Xiugai(1000);
	A = test;
	A.Show();

	 return 0;  
}  

输出为：

creat: 1
1
1021

creat: 5
1
1021

delete: 1
delete: 1

对象A，初始化时，是调用自己的构造函数初始化，这个时候再从test对象复制过来东西，没走我定义的拷贝构造函数（因为要是走了，就会有 “copy”这个文本输出）。但是我写的拷贝构造函数里只拷贝了a的值，没拷贝c的值。但输出结果是，变量a和c都从test复制到了A。这里是没调用拷贝构造函数，调用的是赋值操作 “=” 。 

#include <iostream>  
using namespace std; 

class CExample   
{  
private:  
 	int a;  
	int c;
  
public:  
 //构造函数  
 CExample(int b)  
 {   
	  a = b;  
	  c = 1021;
	  cout<<"creat: "<<a<<endl;  
 }  
  
 //拷贝构造  
 CExample(const CExample& C)  
 {  
	  a = C.a;  
	  cout<<"copy"<<endl;  
 }  
   
 //析构函数  
 ~CExample()  
 {  
  	cout<< "delete: "<<a<<endl;  
 }  
  
void xiugai(int d)
{
	c = d ;
}
	
 void Show ()  
 {  
 	cout<<a<<endl;
	cout<<c<<'\n'<<endl;
 }  
};  

int main()  
{  
 	CExample test(1);
	test.Show();
	
	CExample A = test;
	A.Show();

	 return 0;  
}  

输出为：

creat: 1
1
1021

copy
1
0

delete: 1
delete: 1

对象A用test做的初始化，这时走了我写的拷贝构造函数，因为有“copy“文本输出，而且我写的拷贝构造函数里，只拷贝了a的值，没拷贝c的值。这里对象A初始化没走构造函数，走的是拷贝构造函数，所以c的初始化也没做成。最后只能是缺省值0。

根据这俩实验，验证了一个问题，复制的时候，拷贝构造函数只在拷贝初始化时，才被调用；一般的赋值，不调用拷贝构造函数。

     class A;
     A a;
     A b = a;//拷贝构造
     A c(a);//拷贝构造
     A d;
     d = a;//赋值

根据【详解1】里的实验，如果类中有“动态分配的语句 或 静态数据成员”，则必须手工写拷贝构造函数（手工实现深拷贝），防止系统缺省的浅拷贝被调用。
动态分配的变量，不是可以随时改变空间，而是根据需求，分配一个固定大小的空间，空间尺寸由变量控制。
还有，【详解1】文中，对防止默认拷贝发生的操作方式，没搞懂。留着以后再研究吧~
----------------------------------------分割线------------------------------------------------------
一个月后来看这些，当时的侧重点在研究什么时刻触发拷贝构造函数。
其实copy constuctor的关键用处在深拷贝，当类中有静态变量/申请的堆空间时，必须使用copy constuctor，复制的时候，涉及到静态变量和堆空间的变量时，开新的内存。以防delete时重复回收同一块内存。而其他时刻的复制，如果类中有静态变量/申请的堆空间时，也该使用某种方法来进行深拷贝。小甲鱼的C++教程里提供了一个思路，通过重载【=】这个运算符，将静态变量/申请的堆空间这种变量复制的时候开新内存，进行深拷贝操作。
下面附上小甲鱼的测试代码，其中有些BUG，此处已更正。
#include <iostream>
#include <string>

class MyClass
{
public:
	MyClass(int *p);
	MyClass(const MyClass &rhs);
	~MyClass();

	MyClass &operator=(const MyClass &rhs);
	void print();
private:
	int *ptr;
};

MyClass::MyClass(int *p)
{
	std::cout << "进入主构造器\n";
	ptr = p;
	std::cout << "离开主构造器\n";
}

MyClass::MyClass(const MyClass &rhs)
{
	std::cout << "进入副本构造器\n";
	//*this = rhs;
	ptr = new int;
	*ptr = *rhs.ptr;
	std::cout << "离开副本构造器\n";
}

MyClass::~MyClass()
{
	std::cout << "进入析构器\n";
	delete ptr;
	std::cout << "离开析构器\n";
}

MyClass &MyClass::operator=(const MyClass &rhs)
{
	std::cout << "进入赋值语句重载\n";
	if( this != &rhs )
	{
		delete ptr;

		ptr = new int;
		*ptr = *rhs.ptr;
	}
	else
	{
		std::cout << "赋值号两边为同个对象，不做处理！\n"; // obj1 = obj1;
	}

	std::cout << "离开赋值语句重载\n";

	return *this;
}

void MyClass::print()
{
	std::cout << *ptr << std::endl;
}

int main()
{
	MyClass obj1(new int(1));
	MyClass obj2(new int(2));
	obj2 = obj1;
	obj1.print();
	obj2.print();

	std::cout << "-------------------------------\n";

	MyClass obj3(new int(3));
	MyClass obj4 = obj3;
	obj3.print();
	obj4.print();

	std::cout << "-------------------------------\n";

	MyClass obj5(new int(5));
	obj5 = obj5;
	obj5.print();

	system("pause");
	return 0;
}

运行结果：
进入主构造器
离开主构造器
进入主构造器
离开主构造器
进入赋值语句重载
离开赋值语句重载
1
1
-------------------------------
进入主构造器
离开主构造器
进入副本构造器
离开副本构造器
3
3
-------------------------------
进入主构造器
离开主构造器
进入赋值语句重载
赋值号两边为同个对象，不做处理！
离开赋值语句重载
5