27.1 代理模式 VS 装饰模式
27.1.1 代理模式
（1）场景：客人找运动员代理要求安排运动员参加比赛
（2）说明：代理人有控制权，可以拒绝客人的要求，也可以答应安排，甚至自己下去跑（因为有些运动员本身就作自己的代理）
【编程实验】找代理安排运动员比赛
//结构型模式大PK——代理模式和装饰模式
//实例：找代理安排运动员比赛
#include <iostream>
#include <ctime>
using namespace std;
//抽象运动员
class IRunner
{
public:
virtual void run() = 0;
virtual ~IRunner() {}
};
//运动员
class Runner : public IRunner
{
public:
void run()
{
cout << "运动员跑步，动作很潇洒" << endl;
}
};
//代理人(也与运动员一样，实现同一接口)
class RunnerAgent : public IRunner
{
Runner* runner;
public:
RunnerAgent(Runner* runner)
{
srand((int)time(NULL));
this->runner = runner;
}
void run()
{
if((rand() % 2) ==0)
{
cout << "代理人同意安排运动员跑步" << endl;
runner->run();
}
else
{
cout << "代理人心情不好，不安排运动员跑步" << endl;
}
}
};
int main()
{
//定义一个运动员
Runner* runner = new Runner();
//定义代理人
IRunner* agent = new RunnerAgent(runner);
//要求运动员跑步
cout << "===客人找到代理要求运动员去跑步" << endl;
//为演示，比如洽谈了10次
for(int i=0; i<10; i++)
{
cout <<"第" <<i+1 <<"次洽谈结果：";
agent->run();
cout << endl;
}
delete runner;
delete agent;
return 0;
};27.1.2 装饰模式
（1）装饰模式：对类的功能进行加强
【编程实验】安装喷气装置
//结构型模式大PK——代理模式和装饰模式
//实例：为飞机安装喷气动力装置
#include <iostream>
#include <ctime>
using namespace std;
//飞行接口
class IFly
{
public:
virtual void fly() = 0;
virtual ~IFly() {}
};
//飞机
class AirPlane : public IFly
{
public:
void fly()
{
cout << "飞机正在飞行..." << endl;
}
};
//JetFly
class JetFly : public IFly
{
IFly* airPlane;
public:
JetFly(IFly* airPlane)
{
this->airPlane = airPlane;
}
void speedUp()
{
cout << "为飞机加装了喷气动力装置，正在加速中..." << endl;
}
void fly()
{
speedUp();
airPlane->fly();
}
};
int main()
{
//定义一架飞机
IFly* airPlane = new AirPlane();
//定义装饰类，对功能进行加强
IFly* jet = new JetFly(airPlane);
cout << "===增加功能后的飞机" << endl;
jet->fly();
delete jet;
delete airPlane;
return 0;
};27.1.3 最佳实践
（1）装饰类对被装饰的类的行为没有决定权，只有增强作用。而代理可以控制对被代理人的访问。
（2）代理模式是把当前的行为或功能委托给其他对象执行，代理类负责接口限定（如是否可以调用真实角色，一般不对被代理功能当修饰，而是保证原汁原叶的调用。
（3）装饰模式在保证接口不变的情况下加强类的功能，它保证的是被修饰对象功能比原来丰富（当然也可以减弱），但不做准入条件和准入参数的过滤。
27.1.3 最佳实践
（1）装饰类对被装饰的类的行为没有决定权，只有增强作用。而代理可以控制对被代理人的访问。
（2）代理模式是把当前的行为或功能委托给其他对象执行，代理类负责接口限定（如是否可以调用真实角色，一般不对被代理功能当修饰，而是保证原汁原叶的调用。
（3）装饰模式在保证接口不变的情况下加强类的功能，它保证的是被修饰对象功能比原来丰富（当然也可以减弱），但不做准入条件和准入参数的过滤。
27.2 装饰模式 VS 适配器模式
27.2.1 用装饰模式描述丑小鸭
（1）丑小鸭首先是一只天鹅，具备了天鹅所有的行为和属性（即它从天鹅继承而来）
（2）只是小时候，又小、又脏，又不能飞行。随着时间推移，对其属性和行为进行加强，慢慢变成一只白天鹅。
【编程实验】丑小鸭变小天鹅的故事
//结构型模式大PK——装饰模式和适配器模式
//实例：丑小鸭变小天鹅
#include <iostream>
#include <ctime>
using namespace std;
//天鹅接口
class Swan
{
public:
virtual void fly() = 0; //会飞
virtual void cry() = 0; //会叫
virtual void Appearance() = 0; //外观
virtual ~Swan(){}
};
//丑小鸭(本质上是天鹅)
class UglyDuckling : public Swan
{
public:
//丑小鸭还比较小，不能飞
void fly()
{
cout << "不能飞" <<endl;
}
//丑小鸭的叫声
void cry()
{
cout << "叫声是克噜——克噜——克噜" << endl;
}
//丑小鸭的外形
void Appearance()
{
cout << "外形是脏兮兮的白色，毛毛茸茸的大脑袋" <<endl;
}
};
//装饰类
class Decorator : public Swan
{
private:
Swan* swan;
public:
Decorator(Swan* swan)
{
this->swan = swan;
}
void fly()
{
swan->fly();
}
void cry()
{
swan->cry();
}
void Appearance()
{
swan->Appearance();
}
};
//具体的装饰类(外形美化)
class BeautifyAppearance : public Decorator
{
public:
BeautifyAppearance(Swan* swan):Decorator(swan){}
//外表美化处理（重写该方法）
void Appearance()
{
//这里是重新实现，不再调用原来的Decorator::desAppearance()
cout << "外表是纯白色的，非常惹人喜爱" << endl;
}
};
//具体装饰类
class StrongBehavior :public Decorator
{
public:
StrongBehavior(Swan* swan):Decorator(swan){}
//会飞行了
void fly()
{
//这里是完全重新实现了被装饰类飞的功能。
cout << "会飞行了!" << endl;
}
};
int main()
{
cout <<"===很久很久以前，这里有一只丑陋的小鸭子===" << endl;
Swan* duckling = new UglyDuckling();
//展示一下小鸭
duckling->Appearance();
duckling->cry();
duckling->fly();
cout <<"===小鸭子终于发现自己是一只天鹅===" << endl;
//首先外形变化
BeautifyAppearance duckling2(duckling);
StrongBehavior duckling3(&duckling2);
duckling3.Appearance();
duckling3.cry();
duckling3.fly();
delete duckling;
return 0;
};
/*输出结果：
===很久很久以前，这里有一只丑陋的小鸭子===
外形是脏兮兮的白色，毛毛茸茸的大脑袋
叫声是克噜——克噜——克噜
不能飞
===小鸭子终于发现自己是一只天鹅===
外表是纯白色的，非常惹人喜爱
叫声是克噜——克噜——克噜
会飞行了!
*/27.2.2 用适配器模式描述丑小鸭
（1）两个接口：鸭和天鹅。而丑小鸭就相当于适配器。
（2）为了演示适配器的使用，丑小鸭本质上是天鹅，所以应该把鸭子的接口转为天鹅的接口。即鸭子的源接口，目标接口为天鹅。以便让天鹅具备小鸭的一些特点。
【编程实验】一只与众不同的鸭子
//结构型模式大PK——装饰模式和适配器模式
//实例：一只与众不同的鸭子
#include <iostream>
#include <ctime>
using namespace std;
//天鹅接口
class Swan
{
public:
virtual void behavior() = 0; //其他行为，会飞
virtual void cry() = 0; //会叫
virtual void Appearance() = 0; //外观
};
//鸭子的接口
class Duck
{
public:
virtual void behavior() = 0; //会游泳
virtual void cry() = 0; //会叫
virtual void Appearance() = 0; //外观
virtual ~Duck(){}
};
//白天鹅
class WhiteSwan : public Swan
{
public:
void cry()
{
cout << "叫声是克噜——克噜——克噜" << endl;
}
void Appearance()
{
cout << "外形是纯白色，惹人喜爱" << endl;
}
//其他行为
void behavior()
{
cout << "能够飞行" << endl;
}
};
//小鸭子
class Duckling : public Duck
{
public:
void cry()
{
cout << "叫声是嘎——嘎——嘎" << endl;
}
void Appearance()
{
cout << "外形是黄白相间，嘴长" << endl;
}
//描述鸭子的其他行为
void behavior()
{
cout << "会游泳" << endl;
}
};
//丑小鸭相当于适配器的角色，丑小鸭本质上是天鹅，所以应该把鸭子
//的接口转为天鹅的接口。即鸭子的源接口，目标接口为天鹅
class UglyDuckling : public WhiteSwan
{
Duck* duck; //目标接口
public:
UglyDuckling(Duck* duck)
{
this->duck = duck;
}
//丑小鸭的叫声，直接从父类继承
//丑小鸭的外形，直接从父类继承
//其他行为
void behavior()
{
//本身会飞
WhiteSwan::behavior();
//学会鸭子的游泳
duck->behavior();
}
};
int main()
{
cout <<"===鸭妈妈有5个孩子，其中4个都是一个模样==="<< endl;
Duck* duck = new Duckling();
duck->cry();
duck->Appearance();
duck->behavior();
cout <<"===一只独特的小鸭子，模样是这样的==="<< endl;
UglyDuckling uglyDuckling(duck); //丑小鸭
uglyDuckling.cry();
uglyDuckling.Appearance();
uglyDuckling.behavior();
delete duck;
return 0;
};
/*输出结果：
===鸭妈妈有5个孩子，其中4个都是一个模样===
叫声是嘎——嘎——嘎
外形是黄白相间，嘴长
会游泳
===一只独特的小鸭子，模样是这样的===
叫声是克噜——克噜——克噜
外形是纯白色，惹人喜爱
能够飞行
会游泳
*/27.2.3 最佳实践
（1）装饰模式包装的是自己的兄弟类，隶属于同一家族（相同的父类），而适配器模式则修饰的是非血缘关系类。把一个非本家族伪装成本家族的对象，注意是伪装，因此它的本质还是不同的接口对象。
（2）意图不同
装饰模式的意图是加强对象的功能，而适配器模式关注的是转化，两个对象之间的接口转化。
（3）所作用的对象不同
①装饰模式装饰的对象必须是自己的同宗，也就是相同的父类，只要在具有相同的属性和行为情况下，才能比较行为是增加或减弱。
②适配器模式则必须是两个不对象接口对象，因为它着重于转换
（4）场景不同
①装饰模式只要是想增强功能的，都可以用。
②适配器模式则是一个补救模式，一般出现在系统成熟或己经构建完毕的项目中，作为一个紧急处理手段采用。
（5）扩展性不同
装饰模式容易扩展，如果不需要修饰某对象了，可以随时拿掉，而且装饰类也可以继续扩展。但适配器模式就不同，它在两个不同对象之间架起一座沟通的桥染，建立容易，去掉时需要从系统整体考虑是否能够撤销。