作用:使设计的容器有能力包含类型不同而彼此相关的对象。
容器通常只能包含一种类型的对象,所以很难再容器中存储对象本身。存储指向对象的指针,虽然允许通过继承来处理类型不同的问题(多态性),但是也增加了内存分配的额外负担。所以我们通过定义名为代理的对象来解决该问题。代理运行起来和它所代表的对象基本相同,但是允许将整个派生层次压缩在一个对象类型中。
假设有一个表示不同种类的交通工具的类派生层次:
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数组时,所有这些副本也将被清除。