浅拷贝和深拷贝的区别

 先考虑一种情况，对一个已知对象进行拷贝，编译系统会自动调用一种构造函数——拷贝构造函数，如果用户未定义拷贝构造函数，则会调用默认拷贝构造函数。

       先看一个例子，有一个学生类，数据成员时学生的人数和名字：

1. #include <iostream>

2. using namespace std;

3.  

4. class Student

5. {

6. private:

7. int num;

8. char *name;

9. public:

10. Student();

11. ~Student();

12. };

13.  

14. Student::Student()

15. {

16. name = new char(20);

17. cout << "Student" << endl;

18.  

19. }

20. Student::~Student()

21. {

22. cout << "~Student " << (int)name << endl;

23. delete name;

24. name = NULL;

25. }

26.  

27. int main()

28. {

29. {// 花括号让s1和s2变成局部对象，方便测试

30. Student s1;

31. Student s2(s1);// 复制对象

32. }

33. system("pause");

34. return 0;

35. }

       执行结果：调用一次构造函数，调用两次析构函数，两个对象的指针成员所指内存相同，这会导致什么问题呢？name指针被分配一次内存，但是程序结束时该内存却被释放了两次，会导致崩溃！

       这是由于编译系统在我们没有自己定义拷贝构造函数时，会在拷贝对象时调用默认拷贝构造函数，进行的是浅拷贝！即对指针name拷贝后会出现两个指针指向同一个内存空间。

       所以，在对含有指针成员的对象进行拷贝时，必须要自己定义拷贝构造函数，使拷贝后的对象指针成员有自己的内存空间，即进行深拷贝，这样就避免了内存泄漏发生。

        添加了自己定义拷贝构造函数的例子：

1. #include <iostream>

2. using namespace std;

3.  

4. class Student

5. {

6. private:

7. int num;

8. char *name;

9. public:

10. Student();

11. ~Student();

12. Student(const Student &s);//拷贝构造函数，const防止对象被改变

13. };

14.  

15. Student::Student()

16. {

17. name = new char(20);

18. cout << "Student" << endl;

19.  

20. }

21. Student::~Student()

22. {

23. cout << "~Student " << (int)name << endl;

24. delete name;

25. name = NULL;

26. }

27. Student::Student(const Student &s)

28. {

29. name = new char(20);

30. memcpy(name, s.name, strlen(s.name));

31. cout << "copy Student" << endl;

32. }

33.  

34. int main()

35. {

36. {// 花括号让s1和s2变成局部对象，方便测试

37. Student s1;

38. Student s2(s1);// 复制对象

39. }

40. system("pause");

41. return 0;

42. }

        执行结果：调用一次构造函数，一次自定义拷贝构造函数，两次析构函数。两个对象的指针成员所指内存不同。
 总结：浅拷贝只是对指针的拷贝，拷贝后两个指针指向同一个内存空间，深拷贝不但对指针进行拷贝，而且对指针指向的内容进行拷贝，经深拷贝后的指针是指向两个不同地址的指针。
再说几句：
当对象中存在指针成员时，除了在复制对象时需要考虑自定义拷贝构造函数，还应该考虑以下两种情形：
1.当函数的参数为对象时，实参传递给形参的实际上是实参的一个拷贝对象，系统自动通过拷贝构造函数实现；
2.当函数的返回值为一个对象时，该对象实际上是函数内对象的一个拷贝，用于返回函数调用处。

3.浅拷贝带来问题的本质在于析构函数释放多次堆内存，使用std::shared_ptr，可以完美解决这个问题。