形象地聊聊C++中的浅拷贝与深拷贝

         先来看一个简单的程序：

 

#include <iostream>
using namespace std;

class Point
{
public:
	int x;
	int y;

	Point(int xx, int yy)
	{
		x = xx;
		y = yy;
	}
};

int main()
{
	Point A(1, 2);
	Point B(A); // 执行了编译器默认的浅拷贝
	cout << B.x << endl; // 1
	cout << B.y << endl; // 2

	return 0;
}

      

 

       好， 继续看：

 

#include <iostream>
using namespace std;

class Point
{
public:
	int x;
	int y;

	int* pTest;

	Point(int xx, int yy, int* p)
	{
		x = xx;
		y = yy;
		pTest = p;
	}
};

int main()
{
	int m = 0;
	cout << &m  << endl;     // 0013FF7C

	Point A(1, 2, &m);
	cout << A.x << endl;     // 1
	cout << A.y << endl;     // 2
	cout << A.pTest << endl; // 0013FF7C


	Point B(A);              // 执行了编译器默认的浅拷贝
	cout << B.x << endl;     // 1
	cout << B.y << endl;     // 2
	cout << B.pTest << endl; // 0013FF7C

	return 0;
}

      由此可见， 浅拷贝就是浅浅的傻傻的拷贝。 上面这个程序会引出一个问题： 如果A.pTest指向了某一个堆， 那么B.pTest也指向了同一地方。 我们来看看：

 

 

#include <iostream>
using namespace std;

class Point
{
public:
	int x;
	int y;

	int* pTest;

	Point(int xx, int yy)
	{
		x = xx;
		y = yy;
		pTest = new int(100);
	}
};

int main()
{
	Point A(1, 2);
	cout << A.x << endl;      // 1
	cout << A.y << endl;      // 2
	cout << A.pTest << endl;  // 00032738
	cout << *A.pTest << endl; // 100

	Point B(A);               // 执行了编译器默认的浅拷贝
	cout << B.x << endl;      // 1
	cout << B.y << endl;      // 2
	cout << B.pTest << endl;  // 00032738
	cout << *B.pTest << endl; // 100

	return 0;
}

      显然， 如果析构， 则会有两次释放同一堆空间， 危险！！！看看这个危险的代码：

 

 

#include <iostream>
using namespace std;

class Point
{
public:
	int x;
	int y;

	int* pTest;

	Point(int xx, int yy)
	{
		x = xx;
		y = yy;
		pTest = new int(100);
	}

	~Point()
	{
		delete pTest;
	}
};

int main()
{
	// 代码两次释放同一堆空间， 运行的时候出错

	Point A(1, 2);
	cout << A.x << endl;      // 1
	cout << A.y << endl;      // 2
	cout << A.pTest << endl;  // 00032738
	cout << *A.pTest << endl; // 100

	Point B(A);               // 执行了编译器默认的浅拷贝
	cout << B.x << endl;      // 1
	cout << B.y << endl;      // 2
	cout << B.pTest << endl;  // 00032738
	cout << *B.pTest << endl; // 100

	return 0;
}

      上面的代码不仅错误， 而且从逻辑上吧对象A和B无形地建立了关联， 显然是不合理的。

 

 

       看来， 编译器默认的拷贝构造函数是太肤浅了， 编译器不可能做那么多东西， 从逻辑上来讲，也无法做。 是该搞点深的了， 来看程序员自己需要写的深拷贝：

 

#include <iostream>
using namespace std;

class Point
{
public:
	int x;
	int y;

	int* pTest;

	Point(int xx, int yy)
	{
		x = xx;
		y = yy;
		pTest = new int(100);
	}

	~Point()
	{
		delete pTest;
	}

	Point(Point& P)  // 不能是Point(Point P)
	{
		x = P.x;
		y = P.y;
		int value = *P.pTest;
		pTest = new int(value);
	}
};

int main()
{
	Point A(1, 2);
	cout << A.x << endl;      // 1
	cout << A.y << endl;      // 2
	cout << A.pTest << endl;  // 00032738
	cout << *A.pTest << endl; // 100

	Point B(A);               // 执行了程序员自己写的深拷贝
	cout << B.x << endl;      // 1
	cout << B.y << endl;      // 2
	cout << B.pTest << endl;  // 00030930
	cout << *B.pTest << endl; // 100

	return 0;
}

      这就是深拷贝， 依靠程序员自己的实现， 撇清A对象和B对象的关系。

 

 

      来个形象的总结吧： 

      浅拷贝： 丈夫有100元， 取了个没有钱的妻子后， 自己与妻子共同掌管这100元， 花着花着， 有可能吵架呢
      深拷贝： 丈夫有100元， 取了个有100块钱的妻子后， 自己有100， 妻子有100，  各花各的， 互不干扰， 没有什么争吵