对C++沉思录中代理类实现的质疑和修改

转自http://blog.chinaunix.net/uid-25909722-id-2182249.html

《C++沉思录》是一本十分经典的C++参考书籍。虽然该书出版于1997年，但是，即使是现在读来，对学

习和掌握C++还是十分有价值的。一口气读到第五章《代理类》时，发现其中演示的例子似乎有不妥之处，
可以进行一定的改进。
第五章讲的是为属于同一个继承体系的对象设计一个容器。该容器要能容纳该继承体系中所有类的对象。
其中用到了代理类的方法来实现。实现的原理是：为每一个对象利用复制构造函数生产一个复制品，然后
以该复制品为参数构造一个他的代理对象，然后将代理对象保存在容器中，也就间接的将复制品对象保存
在了容器中。书中的代码如下（进行了很小的一些无关痛痒的改动）：

1. #include <iostream>
   
2. using std::cout;
   
3. using std::endl;
4. 
   
5. class Vehicle {
   
6. public:
   
7.     virtual ~Vehicle(){}
   
8.     virtual double weight() const = 0;
   
9.     virtual void start() = 0;
   
10.     virtual Vehicle* copy() const = 0;
    
11.     // ...
12. protected:
    
13.     double weights;
    
14. };
    
15. 
    
16. class RoadVehicle: public Vehicle
    
17. {
    
18. public:
    
19.     Vehicle* copy() const{
    
20.         cout << "RoadVehicle.copy()" << endl;
    
21.         return new RoadVehicle(*this);    //调用默认复制构造函数
    
22.     }
    
23.     virtual double weight() const { return weights;}
    
24.     void start(){ cout << "RoadVehicle.start()" << endl; }
25. };
    
26. 
    
27. class AutoVehicle: public RoadVehicle
    
28. {
    
29. public:
    
30.     Vehicle* copy()const{
    
31.         cout << "AutoVehicle.copy()" << endl;
    
32.         return new AutoVehicle(*this);    //调用默认复制构造函数
    
33.     }
    
34.     void start(){ cout << "AutoVehicle.start()" << endl; }
    
35. };
    
36. 
    
37. class Aircraft: public Vehicle
    
38. {
    
39. public:
    
40.     Vehicle* copy()const{
    
41.         cout << "Aircraft.copy()" << endl;
    
42.         return new Aircraft(*this);    //调用默认复制构造函数
    
43.     }
    
44.     double weight() const { return weights;}
    
45.     void start(){ cout << "Aircraft.start()" << endl; }
    
46. };
    
47. 
    
48. class Helicopter: public Aircraft
    
49. {
    
50. public:
    
51.     Vehicle* copy()const{
    
52.         cout << "Helicopter.copy()" << endl;
    
53.         return new Helicopter(*this);    //调用默认复制构造函数
    
54.     }
    
55.     void start(){ cout << "Helicopter.start()" << endl; }
    
56. };
57. /*
    
58.  * Vehicle类的代理类VehicleSurrogate：
    
59.  */
    
60. class VehicleSurrogate
    
61. {
    
62. public:
    
63.     VehicleSurrogate(): vp(0) {}
    
64.     VehicleSurrogate(const Vehicle& v): vp(v.copy()) { }
    
65.     ~VehicleSurrogate(){ delete vp; }
    
66.     VehicleSurrogate(const VehicleSurrogate& v): vp(v.vp ? v.vp->copy() : 0) {}
    
67.     VehicleSurrogate& operator=(const VehicleSurrogate& v){
    
68.         if(&v != this){
    
69.             delete vp;
    
70.             vp = (v.vp ? v.vp->copy() : 0);
    
71.         }
    
72.         return *this;
    
73.     }
74.     double weight() const{
    
75.         if(vp == 0)
    
76.             throw "empty VehicleSurrogate.weight()";
    
77.         return vp->weight();
    
78.     }
    
79.     void start(){
    
80.         if(vp == 0)
    
81.             throw "empty VehicleSurrogate.start()";
    
82.         vp->start();
    
83.     }
    
84.     // ...
85. private:
    
86.     Vehicle* vp;
    
87. };
    
88. 
    
89. int main()
    
90. {
    
91.     VehicleSurrogate parking_lot[10];
    
92.     RoadVehicle rv;
    
93.     AutoVehicle av;
    
94.     Aircraft    airv;
    
95.     Helicopter    heli;
    
96. 
    
97.     parking_lot[0] = rv;
    
98.     parking_lot[1] = av;
    
99.     parking_lot[2] = airv;
    
100.     parking_lot[3] = heli;
     
101. 
     
102.     parking_lot[0].start();
     
103.     parking_lot[1].start();
     
104.     parking_lot[2].start();
     
105.     parking_lot[3].start();
     
106. 
     
107.     return 0;
     
108. }

编译：g++ -Wall -o vehicle vehicle.cpp
运行：./vehicle
结果：
RoadVehicle.copy()
RoadVehicle.copy()
AutoVehicle.copy()
AutoVehicle.copy()
Aircraft.copy()
Aircraft.copy()
Helicopter.copy()
Helicopter.copy()
RoadVehicle.start()
AutoVehicle.start()
Aircraft.start()
Helicopter.start()
对于这个运行结果我们肯定会产生疑问：为什么对象的copy()函数会调用两次呢？
仔细分析代码不难看出：每一个这样的 parking_lot[0] = rv; 赋值操作其中隐含会调用的函数为：
1.先调用VehicleSurrogate::VehicleSurrogate(const Vehicle& v): vp(v.copy()) { }构造函数，
这里调用了一次copy()函数。通过该函数我们得到了一个类Vehicle的代理类VehicleSurrogate的对象。
2.对于等号=显然会调用VehicleSurrogate::
VehicleSurrogate& operator=(const VehicleSurrogate& v)赋值操作符函数，这里又调用了一次
copy()函数。所以一次赋值操作：parking_lot[0] = rv; 导致了两次copy()函数的调用。
导致的结果是：
在调用VehicleSurrogate::VehicleSurrogate(const Vehicle& v): vp(v.copy()) { }构造函数时
v.copy()调用的是：

1. Vehicle* RoadVehicle:: copy() const{
   
2.       cout << "RoadVehicle.copy()" << endl;
   
3.       return new RoadVehicle(*this); //调用默认复制构造函数
   
4. }

这里调用了RoadVehicle的默认复制构造函数，得到了一个类RoadVehicle的对象rv的一个复制体。
在调用VehicleSurrogate& operator=(const VehicleSurrogate& v)赋值操作符函数时，其代码
如下：

1. VehicleSurrogate& operator=(const VehicleSurrogate& v){
   
2.         if(&v != this){
   
3.             delete vp;
   
4.             vp = (v.vp ? v.vp->copy() : 0);
   
5.         }
   
6.         return *this;
7. }

显然parking_lot[0] 和由VehicleSurrogate::VehicleSurrogate(const Vehicle& v)构造函数得到
的对象不是同一个对象，所以会执行： delete vp;将刚由类VehicleSurrogate的构造函数生产的对象
又释放掉，然后再一次执行：vp = (v.vp ? v.vp->copy() : 0); 实际上又调用了一次：

1. Vehicle* RoadVehicle:: copy() const{
   
2.       cout << "RoadVehicle.copy()" << endl;
   
3.       return new RoadVehicle(*this); //调用默认复制构造函数
   
4. }

函数。很显然这是十分的不合理的。因为这里是：调用了两次RoadVehicle类的复制构造函数，
得到了RoadVehicle类的两个对象，进而又释放掉其中一个对象。
显然合理的过程应该是：只调用一次RoadVehicle类的复制构造函数，得到一个存储在堆上的对象
然后将代理类VehicleSurrogate的对象的vp指针指向该对象即可。

既然找到了原因，那么如何修改代码呢？
很简单我们只要在代理类VehicleSurrogate中增加一个成员函数即可：

1. void operator=(Vehicle& v){
   
2.         vp = ((&v != 0)? v.copy() : 0);
   
3. }

这样赋值操作的代码：parking_lot[0] = rv; 就不会去调用VehicleSurrogate的构造函数和
赋值操作符函数了，而是直接调用我们定义的函数：
void VehicleSurrogate::operator=(Vehicle& v)。这样就避免了两次调用copy()函数。
最终修改的代码如下：

1. #include <iostream>
   
2. using std::cout;
   
3. using std::endl;
4. 
   
5. class Vehicle {
   
6. public:
   
7.     virtual ~Vehicle(){}
   
8.     virtual double weight() const = 0;
   
9.     virtual void start() = 0;
   
10.     virtual Vehicle* copy() const = 0;
    
11.     // ...
12. protected:
    
13.     double weights;
    
14. };
    
15. 
    
16. class RoadVehicle: public Vehicle
    
17. {
    
18. public:
    
19.     Vehicle* copy() const{
    
20.         cout << "RoadVehicle.copy()" << endl;
    
21.         return new RoadVehicle(*this);    //调用默认复制构造函数
    
22.     }
    
23.     virtual double weight() const { return weights;}
    
24.     void start(){ cout << "RoadVehicle.start()" << endl; }
    
25. 
    
26. };
    
27. 
    
28. class AutoVehicle: public RoadVehicle
    
29. {
    
30. public:
    
31.     Vehicle* copy()const{
    
32.         cout << "AutoVehicle.copy()" << endl;
    
33.         return new AutoVehicle(*this);    //调用默认复制构造函数
    
34.     }
    
35.     void start(){ cout << "AutoVehicle.start()" << endl; }
    
36. };
    
37. 
    
38. class Aircraft: public Vehicle
    
39. {
    
40. public:
    
41.     Vehicle* copy()const{
    
42.         cout << "Aircraft.copy()" << endl;
    
43.         return new Aircraft(*this);    //调用默认复制构造函数
    
44.     }
    
45.     double weight() const { return weights;}
    
46.     void start(){ cout << "Aircraft.start()" << endl; }
    
47. };
    
48. 
    
49. class Helicopter: public Aircraft
    
50. {
    
51. public:
    
52.     Vehicle* copy()const{
    
53.         cout << "Helicopter.copy()" << endl;
    
54.         return new Helicopter(*this);    //调用默认复制构造函数
    
55.     }
    
56.     void start(){ cout << "Helicopter.start()" << endl; }
    
57. };
    
58. 
    
59. /*
    
60.  * Vehicle类的代理类VehicleSurrogate：
    
61.  */
    
62. class VehicleSurrogate
    
63. {
    
64. public:
    
65.     VehicleSurrogate(): vp(0) {}
    
66.     VehicleSurrogate(const Vehicle& v): vp(v.copy()) { cout << "VehicleSurrogate(const Vehicle& v)" << endl;}
    
67.     ~VehicleSurrogate(){ delete vp; }
    
68.     VehicleSurrogate(const VehicleSurrogate& v): vp(v.vp ? v.vp->copy() : 0) {}
    
69.     VehicleSurrogate& operator=(const VehicleSurrogate& v){
    
70.         if(&v != this){
    
71.             cout << "VehicleSurrogate& operator=(const VehicleSurrogate& v)" << endl;
    
72.             delete vp;
    
73.             vp = (v.vp ? v.vp->copy() : 0);
    
74.         }
    
75.         return *this;
    
76.     }
    
77.     void operator=(Vehicle& v){
    
78.         vp = ((&v != 0)? v.copy() : 0);
    
79.     }
80.     double weight() const{
    
81.         if(vp == 0)
    
82.             throw "empty VehicleSurrogate.weight()";
    
83.         return vp->weight();
    
84.     }
    
85.     void start(){
    
86.         if(vp == 0)
    
87.             throw "empty VehicleSurrogate.start()";
    
88.         vp->start();
    
89.     }
    
90.     // ...
91. private:
    
92.     Vehicle* vp;
    
93. };
    
94. 
    
95. int main()
    
96. {
    
97.     VehicleSurrogate parking_lot[10];
    
98.     RoadVehicle rv;
    
99.     AutoVehicle av;
    
100.     Aircraft    airv;
     
101.     Helicopter    heli;
102. 
     
103.     parking_lot[0] = rv;
     
104.     parking_lot[1] = av;
     
105.     parking_lot[2] = airv;
     
106.     parking_lot[3] = heli;
     
107. 
     
108.     parking_lot[0].start();
     
109.     parking_lot[1].start();
     
110.     parking_lot[2].start();
     
111.     parking_lot[3].start();
     
112. 
     
113.     return 0;
     
114. }

编译：g++ -Wall -o vehicle vehicle.cpp
运行：./vehicle
结果：
RoadVehicle.copy()
AutoVehicle.copy()
Aircraft.copy()
Helicopter.copy()
RoadVehicle.start()
AutoVehicle.start()
Aircraft.start()
Helicopter.start()
显然copy()函数只调用一次。
从中得到的一点理会：我们在阅读技术书籍的时候，一定要多问一个为什么，一定要深挖下去，要保持
怀疑的态度--尽信书不如无书