默认拷贝构造函数&默认赋值操作

做了一道题，错了。收藏下：

1. #include <iostream>  
2. #include <cstdlib>  
3.   
4. using namespace std;  
5.   
6. class Person  
7. {  
8. public:  
9.     virtual void Say()  
10.     {  
11.         cout << "我是个人." << endl;  
12.     }  
13.       
14.     ~Person()  
15.     {  
16.         cout << "别了..." << endl;  
17.     }  
18. };  
19.   
20. class Beauty : public Person  
21. {  
22. public:  
23.     Beauty()  
24.         : _p (new int)  
25.     {  
26.           
27.     }  
28.       
29.     ~Beauty()  
30.     {  
31.         delete _p;  
32.     }  
33.   
34.     virtual void Say()  
35.     {  
36.         cout << "我是个美人~~~." << endl;  
37.     }  
38.       
39. private:  
40.     int* _p;  
41. };  
42.   
43. void test()  
44. {  
45.     Beauty b1;  
46.     Beauty b2=b1;      
47. }  
48.   
49. int main()  
50. {      
51.     test();  
52.       
53.     return 0;      
54. }  

A : 没什么问题，编译通过，运行也不报错。
B : 会有运行问题，第46行调用了默认拷贝操作，造成b1和b2中的_p是指向同一段数据，结果析构时，同一段内存将被释放两次。
C : 除了B的问题外，基类析构函数不是虚的(virtual)，这显然也是一个问题。
D : 认同C，但认为B的表达有点小误差，第46行既然用的是“=”操作符，那就应该调用的是默认的赋值操作。

答案：C（自己选择了D）

分析：

1, Person既作为基类存在，又确实拥有一个虚函数 Say。那良好的设计确实应该是提供virtual的析构函数。否则，以下代码就会有问题： Person *p = new Beauty; delete p // Beauty中的_p内存被泄漏了。
2.46行等同以下操作： Beauty b2(b1); 它调用的是拷贝构造。如果是这么写： Beauty b2; b2 = b1; 那么调用的才是默认的赋值操作，这时D就是对的。当然，这里的重点是： 默认的拷贝构造也好，默认认的赋值操作也好，对对象的成员数据，都是“浅拷贝”，结果两个对象的_p确实会指向同一块内存。打个比方，指针就像存折，折子上有100万元。浅拷贝只是把存折复印一份，b1和b2各一份。帐号相同，结果银行里的钱当然是同一份。想要实现“深拷贝”（让银行里的钱也变两份），需要自己写拷贝构造和赋值操作。