C++中关于拷贝构造函数和重载赋值运算符的一些体会

一、编译器自动调用拷贝构造函数的情况

1.当用一个已经存在的对象初始化被定义的新对象时。

2.如果函数的参数为类的对象，而参数的传递方式为传值传递，当发生函数调用时，相当于用实参对象初始化正在创建的形参对象，所以要调用拷贝构造函数。

3.如果一个函数的返回值为类的对象，当函数执行结束返回主调函数时，由于返回对象是被调函数的局部变量，随着函数的执行结束，它也会被自动销毁，所以编译器会在主调函数中创建一个临时对象，用来存放函数返回对象的值。

二、一个C++的例子

#include <iostream>
using namespace std;

class A
{
public:
	A()
	{
		numptr = new int(1);
	}
	A(int num)
	{
		numptr = new int(num);
	}
	A(A &);
	~A()
	{
		cout<<"析构函数被调用"<<endl;
		delete numptr;
	}
	void setnum(int num)
	{
		*numptr = num;
	}
	int getnum()
	{
		return *numptr;
	}


private:
	int *numptr;
};

A::A(A &a)
{
	numptr = new int(*a.numptr);
	cout<<"类的拷贝构造函数被调用!\n";
}

void main()
{
	A a1(10);
	A a2;
	a2 = a1;
	cout<<"对象a1中存放的整数为："<<a1.getnum()<<endl;
	cout<<"对象a2中存放的整数为："<<a2.getnum()<<endl;
	a1.setnum(20);
	cout<<"对象a1中存放的整数为："<<a1.getnum()<<endl;
	cout<<"对象a2中存放的整数为："<<a2.getnum()<<endl;
}

运行结果如下：

此程序执行过程发生浅拷贝，由于a2=a1;这条语句是赋值操作而不是初始化对象，所以赋值操作不调用类的拷贝构造函数。而是将赋值号右边的对象内容按字节拷贝到赋值号左边的对象中，从而导致两个对象中的指针类型成员指向了相同的地址。同时在程序结束时析构函数被调用两次，使得同一地址的内存被释放两次，程序产生异常。

三、使用重载赋值运算符避免上述问题

#include <iostream>
using namespace std;

class A
{
public:
	A()
	{
		numptr = new int(1);
	}
	A(int num)
	{
		numptr = new int(num);
	}
	A(A &);
	~A()
	{
		cout<<"析构函数被调用"<<endl;
		delete numptr;
	}
	void setnum(int num)
	{
		*numptr = num;
	}
	int getnum()
	{
		return *numptr;
	}

	A& operator = (A);

private:
	int *numptr;
};

A::A(A &a)
{
	numptr = new int(*a.numptr);
	cout<<"类的拷贝构造函数被调用!\n";
}

A& A::operator =(A a)
{
	this->numptr = new int(*a.numptr);
	cout<<"重载赋值操作符函数被调用"<<endl;
	return *this;
}

void main()
{
	A a1(10);
	A a2;
	a2 = a1;
	cout<<"对象a1中存放的整数为："<<a1.getnum()<<endl;
	cout<<"对象a2中存放的整数为："<<a2.getnum()<<endl;
	a1.setnum(20);
	cout<<"对象a1中存放的整数为："<<a1.getnum()<<endl;
	cout<<"对象a2中存放的整数为："<<a2.getnum()<<endl;
}

运行结果如下：

结果分析：

可以看到赋值语句在调用重载操作的过程中使用了拷贝构造函数。这是由于，在调用重载赋值函数的时候，a1作为一个实参使用传值传递初始化了形参a（即使用了上述调用拷贝构造函数的情况中的第二种），为赋值函数创造了一个a1的副本作为赋值的临时对象，然后用这个临时对象创建了一个新的对象，最后返回给了主函数中的a2。（注意，可以通过调试发现，拷贝构造函数创建的对象就是在重载赋值函数中的a，因为在调试过程中可以发现它们的地址是相同的）最后，在重载赋值函数结束的时候，调用了析构函数，释放了临时对象a。下面看看在没有拷贝构造函数的情况下会发生什么。

#include <iostream>
using namespace std;

class A
{
public:
	A()
	{
		numptr = new int(1);
	}
	A(int num)
	{
		numptr = new int(num);
	}
//	A(A &);
	~A()
	{
		cout<<"析构函数被调用"<<endl;
		delete numptr;
	}
	void setnum(int num)
	{
		*numptr = num;
	}
	int getnum()
	{
		return *numptr;
	}

	A& operator = (A);

private:
	int *numptr;
};
/*
A::A(A &a)
{
	numptr = new int(*a.numptr);
	cout<<"类的拷贝构造函数被调用!\n";
}
*/
A& A::operator =(A a)
{
	this->numptr = new int(*a.numptr);
	cout<<"重载赋值操作符函数被调用"<<endl;
	return *this;
}

int main()
{
	A a1(10);
	A a2;
	a2 = a1;
	cout<<"对象a1中存放的整数为："<<a1.getnum()<<endl;
	cout<<"对象a2中存放的整数为："<<a2.getnum()<<endl;
	a1.setnum(20);
	cout<<"对象a1中存放的整数为："<<a1.getnum()<<endl;
	cout<<"对象a2中存放的整数为："<<a2.getnum()<<endl;

	return 0;
	
}

运行结果如下：

可以看到输出a1中指针的内容乱码，这就是由于没有定义拷贝构造函数，而调用了系统自带的默认拷贝构造函数，将a1按字节复制给了形参a，以至于在重载赋值函数结束的时候，释放了a的空间，同时也将实参a1中指针指向的空间释放，从而输出的是一个随机的数。

至此结束，希望有独到见解的分享指正。。。。。。