• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

《C++沉思录》摘引——代理类(Surrogate)

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

问题引入

假设有一个表示不同种类的交通工具的类派生层次:

 1 class Vehicle {}
 2 {
 3 public:
 4     virtual void start() = 0;
 5     // ...
 6 };
 7 class RoadVehicle : public Vehicle {};
 8 class AutoVehicle : public RoadVehicle {};
 9 class Aircraft : public Vehicle {};
10 class Helicopter : public Aircraft {};

 其中,Vehicle是一个抽象基类。在实际中,我们可能会使用某种容器类,比如数组:

1 Vehicle parking_lot[10];

 上述定义没有产生预期的效果,为什么?由于Vehicle本身不会有对象,也就不可能有其对象数组了。

 

如果我们去掉类Vehicle的所有纯虚函数,写出类似于下面的语句,会有什么效果呢?

1 Automobile x = /* ... */;
2 parking_lot[i] = x;

 答案是:把x赋给parking_lot的元素,会把x转换成一个Vehicle对象,同时会丢失所有在Vehicle类中没有的成员。该赋值语句还会把这个剪裁了的对象复制到parking_lot数组中。

这样,我们只能说parking_lot是Vehicles的集合,而不是所有继承自Vehicle的对象的集合。

 

使用代理类

 有没有一种方法既能让我们避免显示地处理内存分配,又能保持类Vehicle运行时绑定的属性呢?

有!方法是:定义一个行为和Vehicle对象类似,而又潜在地表示了所有继承自Vehicle类的对象的东西。我们把这种类的对象叫做代理(surrogate)。

 1 class VehicleSurrogate
 2 {
 3 public:
 4     VehicleSurrogate() : vp(NULL) {};
 5     VehicleSurrogate(const Vehicle& v) : vp(v.copy()) {};
 6     ~VehicleSurrogate() {};
 7     VehicleSurrogate(const VehicleSurrogate& v) : vp(v.vp ? v.vp->copy() : NULL) {}; //v.vp非零检测
 8     VehicleSurrogate& operator=(const VehicleSurrogate& v) 
 9     {
10         if (this != &v) // 确保没有将代理赋值给它自身
11         {
12             delete vp;
13             vp = (v.vp ? v.vp->copy() : NULL);
14         }
15 
16         return *this;
17     };
18 
19     //来自类Vehicle的操作
20     void start()
21     {
22         if (vp == 0)
23             throw "empty VehicleSurrogate.start()";
24 
25         vp->start();
26     };
27 
28 private:
29     Vehicle* vp;
30 };

 我们再定义两个Vehicle的子类Car和Truck:

 1 class Vehicle
 2 {
 3 public:
 4     virtual void start() = 0;
 5     virtual Vehicle* copy() const = 0//虚拷贝
 6     virtual ~Vehicle() {}
 7 };
 8 
 9 class RoadVehicle : public Vehicle
10 {
11 public:
12     void start() { cout<<"start road vehicle"<<endl; } ;
13     Vehicle* copy() const { return new RoadVehicle(*this); };
14     ~RoadVehicle() {};
15 };
16 
17 class Truck : public RoadVehicle
18 {
19 public:
20     void start() { cout<<"start truck"<<endl; } ;
21     Vehicle* copy() const { return new Truck(*this); };
22     ~Truck() {};
23 };
24 
25 class Car : public RoadVehicle
26 {
27 public:
28     void start() { cout<<"start car"<<endl; } ;
29     Vehicle* copy() const { return new Car(*this); };
30     ~Car() {};
31 };

那么我们就能够实现继承自Vehicle的类的对象的容器:

 1 int _tmain(int argc, _TCHAR* argv[])
 2 {
 3     VehicleSurrogate parking_lot[10];
 4     Truck x;
 5     Car y;
 6     for (int i=0; i<10; i++)
 7     {
 8         // 相当于parking_lot[i] = VehicleSurrogate(x);
 9         // 创建了一个关于对象x的副本,并将VehicleSurrogate对象绑定到该副本,
10         // 然后将这个对象赋值给parking_lot的一个元素。当最后销毁parking_lot数组时,
11         // 所有这些副本也将被消除
12         if (i&1)
13             parking_lot[i] = x; //VehicleSurrogate(x);
14         else
15             parking_lot[i] = y; //VehicleSurrogate(y);
16 
17         parking_lot[i].start();
18     }
19 
20     return 0;
21 }

结果为:

start car

start truck

start car

start truck

start car

start truck

start car

start truck

start car

start truck

 

每个Vehicle代理都代表某个继承自Vehicle类的对象。只要该代理关联着这个对象,该对象就肯定存在。

因此,拷贝代理就会拷贝相应的对象,而给代理赋新值也会先删除旧对象,再拷贝新对象(改变代理类实际关联的那个对象的类型)。

所幸的是,我们在类Vehicle中已有虚拷贝函数copy来完成这些拷贝工作。

 

总结

将继承和容器共用,迫使我们要处理两个问题:控制内存分配和把不同类型的对象放入同一容器中。采用基础的C++技术,用类来表示概念,我们可以同时兼顾这两个问题。我们提出一个名叫代理类的类,这个类的每一个对象都代表另一个对象,该对象可以是位于一个完整继承层次中的任何类的对象。通过在容器中用代理对象而不是对象本身的方式,解决了我们的问题。

 

声明

本文版权归《C++沉思录》原书作者所有!

 


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap