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

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

通过使用另一个同类型的对象来初始化新创建的对象。
复制对象把它作为参数传递给函数。
复制对象，并从函数返回这个对象。

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

深拷贝和浅拷贝：

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

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

下面是我做的测试：

#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: 111021creat: 511021delete: 1delete: 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: 111021copy10delete: 1delete: 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;}

运行结果：

进入主构造器离开主构造器进入主构造器离开主构造器进入赋值语句重载离开赋值语句重载11-------------------------------进入主构造器离开主构造器进入副本构造器离开副本构造器33-------------------------------进入主构造器离开主构造器进入赋值语句重载赋值号两边为同个对象，不做处理！离开赋值语句重载5

秒客网

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

相关文章