代理类的理解

代理类

这是《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函数的。