为什么需要代理类

http://www.cnblogs.com/zhuyp1015/archive/2012/07/25/2609129.html

C++ 程序员都应该知道，只有在程序通过指向基类对象的指针或基类对象的引用调用虚函数时，才会发生运行时的多态现象。

对象的创建和复制不是运行时多态的，这一点严重影响了类的设计。所以，容器——无论是类似于数组或者结构体的内建容器还是用户自定义容器类——只能获得编译时类型一致的元素值。如果有一系列类之间存在继承关系，当我们需要创建、复制和存储对象，而这些对象的确切类型只有到运行时才能知道时，则这种编译时的检查会带来一些麻烦。

通常，解决这个问题的方法是增加一个间接层。传统C模型可能会建议采用指针来实现这个间接层。这样会给需要使用这些类的用户带来负面影响，使得他们必须参与内存管理。C++ 采用了一种更自然的方法，就是定义一个类来提供并隐藏这个间接层。这种类通常叫做句柄类，本片的许多章都将参照或者使用这种技术。句柄类采用简单的形式，把一个单一类型的对象与一个与之有某种特定继承关系的任意类型的对象捆绑起来。所有，句柄可以让我们忽略正在处理的对象的准确类型，同时还能避免指针带来的关于内存管理的麻烦。

如何设计一个容器，能使得它能包含类型不同但是彼此相关的对象？

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

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

下面假设我们要跟踪处理一系列不同种类的Vehicle，首先使用数组来实现：

Vehicle parking_lot[1000];

上面的写法有问题，因为Vehicle作为抽象类是不能被实例化的。

假设可以以实例化，然后进行下面操作：

AutoVehicle  x= /* ... */
Parking_lot[num_vehicles++] = x;

这样也是不行的，x转化为一个Vehicle对象时会产生问题，x 会丢失在Vehicle类中没有的成员，也就是发生了“截断”。

因此，我们只能说parking_lot 是Vehicle的集合，而不是所有继承自Vehicle的对象的集合。

经典解决方案：

常见做法提供一个间接层，最早的合适间接层形式就是存储指针，而不是对象本身：

Vehicle * Parking_lot[1000];          // 指针数组

然后：

AutoVehicle x = /* ... */
Parking_lot[ num_vehicles++ ] = &x;

这种情况带来了新的问题：

一旦x不存在了，Parking_lot就不知道指向哪里了。

我们可以变通一下，让放入Parking_lot的值，指向原来对象的副本，而不直接存放原来对象的地址，例如：

Parking_lot[num_vehicles++]= new AutoVehicle(x);

这个改进方案又带来一个问题，那就是我们必须知道x的静态类型（理解为定义时必须指定对象类型，这里为AutoVehicle）。假如我们想让parking_lot[p]指向的Vehicle的类型和值与parking_lot[q]指向的对象相同，那在我们无法得知parking_lot[q]的静态类型的情况下，我们无法做到这点。

可以想一个办法来复制编译时类型未知的对象：增加虚拟复制函数来复制编译时类型未知的对象

class Vehicle
{
     public:
          virtual Vehicle * copy() const = 0;
     /**/
};

//Vehicle的派生类都实现copy函数
class Truck : public RoadVehicle
{
public:
            Vehicle* copy() const { return new Truck(*this); }
     /**/
};
 
//同时也该增加一个析构函数：
class Vehicle{
          public：
               virtual double weight() const = 0;
               virtual void start() = 0;   
               virtual Vehicle * copy() const = 0;
               virtual ~Vehicle() {}
               // ...
};

假如我们想让parking_lot[p]指向的Vehicle的类型和值与parking_lot[q]指向的对象相同，可以简单是使用如下代码：parking_lot[p] =parking_lot[q].copy();

有没有一种方法既能避免显示地处理内存分配，又能保持Vehicle在运行时绑定的属性？

用类来表示概念！在复制对象的过程中运用这个设计原则，就是定义一个行为和Vehicle对象相似、而又潜在地表示了多有继承自Vehicle类的对象的东西。我们把这种累对象叫做代理类。每个Vehicle代理都代表某个继承自Vehicle类的对象。

class VehicleSurrogate
{
public:
VehicleSurrogate() : vp(NULL) {};
VehicleSurrogate(const Vehicle& v) : vp(v.copy()) {};
~VehicleSurrogate() {};
VehicleSurrogate(const VehicleSurrogate& v) : vp(v.vp ? v.vp->copy() : NULL) {}; //v.vp非零检测
VehicleSurrogate& operator=(const VehicleSurrogate& v) 
{
if (this != &v) // 确保没有将代理赋值给它自身
{
　　delete vp;  //所谓的显示处理内存分配，在该处表现为每次调用赋值就自动释放原来内存。
　　vp = (v.vp ? v.vp->copy() : NULL);
}
 
return *this;
};
 
//来自类Vehicle的操作
void start()
{
if (vp == 0)
　　throw "empty VehicleSurrogate.start()";
 
vp->start();
};
        double weight() const 
        {
               if(vp == 0)
                    throw "empty VehcileSurrogate.weight()";
               return vp->weight();
        }
 
private:
　　Vehicle* vp;
};

现在我们可以进行下面的操作了：

VehcileSurrogate  parking_lot[ 1000 ]
AutoVehicle x;
parking_lot[ num_vehicles++] = x;

最后一条语句等价于：

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

这句话创建了一个关于该对象的副本，并将VehicleSurrogate对象绑定到该副本，然后将这个对象赋值给parking_lot 的一个元素。