代理类的理解

代理类
这是《c++沉思录》第五章的一个自己的理解过程。可能是因为中英文表达的差别吧，作者的说明读起来有些吃力。这里记录了我的理解过程。
1.问题的提出
我们需要存储派生自同一基类的不同派生类的对象时，如何才能将他们存储在同一个容器中呢?
这正是代理类章中提出的问题，这里我只是用中国人的表达习惯进行了转述。
2.可能的解决方案
假设基类：
classVehicle{
public:
virtualvoid showName() const = 0;
intwheels;
};
有一个虚函数用来输出名字，成员变量whells表示该交通工具的轮子数目。
然后基于这个类有两个派生类：
classAircraft: public Vehicle{
public:
Aircraft(){
wheels=2;
}
voidshowName() const {
cout<< "i am a aircraft." << ".number is "<< wheels << endl;
}
};

classHelicopter: public Vehicle{
public:
Helicopter(){
wheels=3;
}
voidshowName() const {
cout<< "i am a helicopter" << ".number is "<< wheels << endl;
}
};
上面两个派生类是实现了基类的虚函数，并且设定了轮子的数目。现在我们要将Aircraft和Helicopter存储在同一个容器中应该怎么？这个例子就是第1节中提到的问题。
一般的我们借助多态行为，可以建立Vehicle的数组，即：
Vehiclev[10];
我们企图用Vehicle数组存储不同的派生类对象。但是Vehicle是虚基类，是不可以实例化的。这种方法行不同。
转而我们存储对象转换为存储Vehicle的指针，即；
Vehicle*v[10];
这个咋看可以达到目的，但是这样引入了大量的指针操作，并且一旦Vehicle指针数据发生任何一个指针错误（如生命期结束）都会直接导致runtimeerror。
转而，我们存储要存储到Vehicle数组中的派生类对象的副本的指针，即：
Aircrafta = new Aircraft;
v[0]= new Aircraft(a);//不能newVehicle
这样增加了内存的负担和要求程序员记得释放副本的空间不说，还引入了一个静态限制，即存储到Vehicle数组中的对象的类型总是确定的，不能是未知的。不然没有办法使用new。
再转而，我们将Vehicle转化为实类，即虚函数不设置为纯虚函数。这样代码：
Vehiclev[10];
是可以使用的，但是又出现了新的问题，如果说Vehicle的派生类有新的成员变量时，在将这种派生类对象存储到v数组中时肯定存在成员变量的丢失（被截断了）。
3.解决方案：代理类
在第二节的分析中，我们发现使用指针数组是可行的，虽然存在明显的不足。这里不看其不足，单看其可行的原因，进而引导我们思考代理类的设计思想是怎么来的。
首先指针可以触发多态行为，即当基类的指针指向派生类对象时，对这个基类指针的使用可以达到调用派生类对象函数的目的。这种借助数组指针的方案还解决了存储时的截断问题，因为存储的只是地址，不存在截断现象。
从这出发，我们可以设计这么一个类，这个类就是Vehicle的代理类，这里代理的含义就是对Vehicle的任何操作都可以通过对代理类的操作达成。那么这个代理类怎么设计？
首先，必须要有Vehicle指针类型的成员变量，不然怎么代理它呢？其二，代理类本身就应该具有复制未知数据类型的派生类对象的能力，这样才不至于出现2中分析的静态限制，这点使用虚复制函数就可以达到了。
基于以上分析，我们要将Vehicle类修改为如下：
classVehicle{
public:
virtualvoid showName() const = 0;
virtualVehicle* copy() = 0;//加入了虚复制的能力，避免静态限制
virtual~Vehicle(){}
intwheels;
};//这个不一定非要采用纯虚的形式的
相应的派生类修改为：
classAircraft: public Vehicle{
public:
Aircraft(){
wheels=2;
}
voidshowName() const {
cout<< "i am a aircraft." << ".number is "<< wheels << endl;
}
Vehicle*copy() {
returnnew Aircraft(*this);//注意这里使用的是Aircraft的默认复//制构造函数，复制的是自己，即自己的副本
}

};

classHelicopter: public Vehicle{
public:
Helicopter(){
wheels=3;
}
voidshowName() const {
cout<< "i am a helicopter" << ".number is "<< wheels << endl;
}
Vehicle*copy() {
returnnew Helicopter(*this);
}//通过copy就可以复制对象自身了，并将副本的指针返回
};
好了，上面的修改使得基类有虚复制的能力，即复制行为也是多态的，那样我们就解决来静态限制了。下面是代理类Surrogate的雏形：
classSurrogate{
public:
Surrogate():vp(0) {}
Surrogate(Vehicle&v){//参数是Vehicle的引用，引用也可以引发多态
vp= v.copy();
}//绑定代理类到被代理类上（实际上绑定的是被被代理类对象的副本）
Surrogate&operator= (Vehicle &v){
vp= v.copy();
}
~Surrogate(){
deletevp;
}
//private:
Vehicle*vp;//指向代理类对象副本
};
当我们有一个派生类对象时，不管这个派生类的类型，我们使用=就可以将这个类赋值给Surrogate对象了，就实现了绑定，此时，代理类的成员vp指向的就是派生类对象的副本。这样我们对Surrogate的操作就是对派生类对象的操作。
可以清楚的看到，我们只要将Vehicle类型的引用作为参数就可以将其绑定到代理类Surrogate上，而不用知道我们被绑定者的具体类型。
有了以上代理类后，我们就可以解决第1节提出的问题了。下面是一段测试程序：
intmain(){
Vehicle*va = new Aircraft;
Vehicle*vh = new Helicopter;
va->showName();
vh->showName();
Surrogates(*va);
s.vp->showName();
Surrogatess[2];
ss[0]= *va;
ss[1]= *vh;
ss[0].vp->showName();
ss[1].vp->showName();
return0;
}
运行结果如下：
xy@ubuntu:~/primer$./a.out
iam a aircraft..number is 2
iam a helicopter.number is 3
iam a aircraft..number is 2
iam a aircraft..number is 2
iam a helicopter.number is 3

可以看到ss[2]容器顺利的存储了不同类型派生类对象。
4.自己的总结
代理类的关键是它的那个成员变量，这个成员变量是实现多态的关键；copy函数不是必须的，当然我们可以不使用copy函数的。