C++代理 Surrogate

容器通常只能包含一种类型的对象，所以很难在容器中存储对象本身。存储指向对象的指针，虽然允许通过继承来处理类型不同的问题（ 多态性 ），但是也增加了内存分配的额外负担。所以我们通过定义名为 代理 的对象来解决该问题 。代理 运行起来和它所代表的对象基本相同，但是允许将整个派生层次压缩在一个对象类型中。

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

class Vehicle{public: virtual double weight() const = 0; virtual void start() = 0; //...};class RoadVehicle:public Vehicle{/*...*/};class AutoVehicle:public Vehicle{/*...*/};class Aircraft:public Vehicle{/*...*/};class Helicopter:public Vehicle{/*...*/};

可见Vehicle是一个抽象基类，有两个纯虚函数表示一些共有属性。下面请看下面这句话为什么不能达到预期的效果：

Vehicle parking_lot[1000];

表面上看是由于Vehicle是一个抽象基类，因此，只有从类Vehicle派生出来的类才能实例化，类Vehicle本身不会有对象，自然也就不会有对象数组了。

       但是，假设我们剔除了类Vehicle中的所有纯虚函数，使其对象存在，那又会出现什么样的情况呢？看下面的语句：

Automobile x=/*...*/;

parking_lot[num_vehicles++] = x;

把x赋给parking_lot的元素，会把x转换成一个Vehicle对象，同时会丢失所有在Vehicle类中没有的成员。该赋值语句还会把这个被剪裁了的对象复制到parking_lot数组中去。这样，我们只能说parking_lot是Vehicle的集合，而不是所有继承自Vehicle的对象的集合。

经典解决方案------提供一个间接层

最早的合适的间接层形式就是存储指针，而不是对象本身：

Vehicle* parking_lot[1000];

然后，就有

Automobile x = /*...*/;

parking_lot[num_vehicles++] = &x;

这种方法解决了迫切的问题，但是也带来了两个新问题。

①我们存储在parking_lot中的是指向x的指针，在上例中是一个局部变量。这样，一旦变量x没有了【作用域】，parking_lot就不知道指向什么东西了。

我们可以这么变通一下，放入parking_lot中的值，不是指向原对象的指针，而是指向它们的副本的指针。当我们释放parking_lot时，也释放其中所指向的全部对象。

②上述修改虽然不用存储指向本地对象的指针，但是它也带来了动态内存管理的负担。另外，只有当我们知道要放到parking_lot中的对象的静态类型后，这种方法才起作用。不知道又会怎样呢？看下面的：

if(p != q)

{

   delete parking_lot[p];

   parking_lot[p] = parking_lot[q];

}

这样的话，parking_lot[p]和parking_lot[q]将指向相同的对象，这不是我们想要的。在看下面的行不行：

if(p != q)

{

   delete parking_lot[p];

   parking_lot[p] = new Vehicle(*parking_lot[q]);

}

这样我们又回到了前面的问题：没有Vehicle类型的对象，即使有，也不是我们想要的（是经过剪裁后的对象）。

如何复制编译时类型未知的对象-------虚复制函数

我们在上面的Vehicle类中加入一个合适的纯虚函数：

class Vehicle 
{ 
public: 
virtual double weight() const = 0; 
virtual void start() = 0;

virtual Vehicle* copy() const = 0; 
 //... 
};

接下来，在每个派生自Vehicle的类中添加一个新的成员函数copy。指导思想就是，如果vp指向某个继承自Vehicle的不确定类的对象，那么vp->copy()会获得一个指针，该指针指向该对象的一个新建的副本。例如：如果Truck继承自（间接或直接）类Vehicle，则它的copy函数就类似于：

Vehicle* Truck::copy() const

{

    return new Truck(*this);

}

当然，处理完一个对象后，需要清除该对象。要做到这一点，就必须确保类Vehicle有一个虚析构函数：

class Vehicle 
{ 
public: 
virtual double weight() const = 0; 
virtual void start() = 0;

virtual Vehicle* copy() const = 0;

virtual ~Vehicle(){} 
 //... 
}; 
有了上面的分析，下面我们就来定义代理类：

class VehicleSurrogate{public:  VehicleSurrogate();  VehicleSurrogate(const Vehicle&);  ~VehicleSurrogate();  VehicleSurrogate(const VehicleSurrogate&);  VehicleSurrogate& operator = (const VehicleSurrogate&);private:  Vehicle* vp;};

上述代理类有一个以const Vehicle&为参数的构造函数，这样就能为任意继承自Vehicle的类的对象创建代理了 （多态性，因为这里是引用参数） 。同时，代理类还有一个缺省构造函数，所以我们能够创建VehicleSurrogate对象的数组。

然而， 缺省构造函数也给我们带来了问题：如果Vehicle是个抽象基类，我们应该如何规定VehicleSurrogate的缺省操作呢？它所指向的对象的类型是什么呢？不可能是Vehicle，因为根本就没有Vehicle对象。为了得到一个更好的方法，我们要引入行为类似于零指针的空代理的概念。能够创建、销毁和复制这样的代理，但是进行其他的操作就视为出错。

下面看各个函数的定义：

VehicleSurrogate::VehicleSurrogate():vp(0){}

VehicleSurrogate::VehicleSurrogate(const Vehicle& v):vp(v.copy()){}//非零的检测室必要的，空代理

VehicleSurrogate::~VehicleSurrogate()

{

      delete vp;//C++标准里面对一个空指针运用delete也是没有问题的

} 
VehicleSurrogate::VehicleSurrogate(const VehicleSurrogate& v):vp(v.vp?v.vp->copy():0){}

VehicleSurrogate& VehicleSurrogate::operator=(const VehicleSurrogate& v)

{

    if(this!=&v)//对赋值操作符进行检测，确保没有将代理赋值给它自身

    {

      delete vp;

      vp=(v.vp?v.vp->copy():0);//非零的检测是必要的，空代理

    }

    return *this;

}

下面就很容易定义我们的数组了：

VehicleSurrogate parking_lot[1000];

Automobile x;

parking_lot[num_vehicles++] = x;

最后一条语句就等价于

parking_lot[num_vehicles++] = VehicleSurrogate(x);

这个语句创建了一个关于对象x的副本，并将VehicleSurrogate对象绑定到该副本，然后将这个对象赋值给parking_lot的一个元素。当最后销毁parking_lot数组时，所有这些副本也将被清除。