前言

     
         在C++的基础语法的学习后,更进一步为应用场景多写代码.其中设计模式是有较大应用空间.

引入

        原本在写容器中适配器类有关的帖子,发现适配模式需要先了解,于是试着先写篇和适配器模式相关的帖子

         理解什么是适配器类,需要知道什么是适配器模式.适配器模式是设计模式的一种.笔者也准备开这个系列的专题,这里就当首个模式介绍.

从接口说起

        接口和实现的关系如图所示 

 

         

         

        这个图可以看成一切设计模式的起源.各种设计模式都可以从本图中演化出来----当然实际操作起来会远远难于一张图(笔者的思维习惯是概念极简,就好像之前把程序看成只做了两件事:修改数据和映射数据到硬件一样).

        接口是一种功能,一个需求;实现类是一种实现,多个实现类是多种实现.就好像变量代表所有能表示的常量.接口和实现的关系类似于变量和常量.接口是"虚"的,实现是"实"的.

        举例:有个喝下午茶的需求,有中式下午茶,吃龟苓膏,喝凉茶;有西式下午茶,喝咖啡,吃蛋糕.用接口与实现表达出来.

/*接口与实现*/
#include<iostream>
using namespace std;

//抽象基类(接口)定义
class Abs_AfternoonTea {
public:
	virtual void	eat() = 0;	//纯虚方法:功能需求
};

//中式下午茶定义
class ChineseTea :public Abs_AfternoonTea{
	int room_number;			//餐厅房间号码
public:
	ChineseTea(int ro) :room_number(ro) {};
	void Guiling_paste(){ cout << "吃龟苓膏" << endl; }
	void cold_tea(){cout<< "喝凉茶" << endl;}
//	int getRoomNumber() { return room_number; }
	void eat() { 
		cout << "在" << room_number << "号房间享用下午茶:" << endl;
		Guiling_paste();
		cold_tea();
	}
};

//西式下午茶定义
class WestTea :public Abs_AfternoonTea {
	int room_number;			//餐厅房间号码
public:
	WestTea(int ro) :room_number(ro) {};
	void coffee() { cout << "喝咖啡" << endl; }
	void cake() { cout << "吃蛋糕" << endl; }
	int getRoomNumber() { return room_number; }
	void eat() {
		cout << "在" << room_number << "号房间享用下午茶:" << endl;
		coffee();
		cake();
	}
};

        测试代码

int main(void) {
	ChineseTea ct(3);
	Abs_AfternoonTea& aat = ct;
	aat.eat();
}

----这种方案的是接口和实现直接对接,没问题

    回顾:需求:下午茶; 实现1:中式下午茶; 实现2:西式下午茶

    现在喝下午茶的需求做一点改变:喝凉茶,吃蛋糕;(中式西式各占一个).如果再按"接口-实现"的方式来设计代码架构,就得再设计一个类MixTea,如下所示: 

//混合下午茶定义
class MixTea :public Abs_AfternoonTea {
	int room_number;			//餐厅房间号码
public:
	WestTea(int ro) :room_number(ro) {};
	void cold_tea() { cout << "喝凉茶" << endl; }
	void cake() { cout << "吃蛋糕" << endl; }
	void eat() {
		cout << "在" << room_number << "号房间享用下午茶:" << endl;
		cold_tea();
		cake();
	}
};

        测试代码:

int main(void) {
	MixTea mt(3);
	Abs_AfternoonTea& aat = mt;
	aat.eat();
}

        问题并没有完全解决,如果下次的需求再改变:喝咖啡,吃龟苓膏.又得再设计一个类,依次类推.

        所以得出结论:

                接口-实现的直接架构是万能的,但扩展性不好

        为了让接口更好地被实现,需要对现有代码修改.适配器登场.

适配器适应方案选择 

        适配器思路:接口由适配器实现(适配器类继承接口).适配器是一个间接类,具体怎么实现由他所包含的对象来决定. 现在把工作细化,每个工作配一个厨师(龟苓膏,凉茶,咖啡,蛋糕各自由一个厨师来做).下面是为适配器准备的类

        接口和适配器类.h

/*适配器以下类定义*/
#include<iostream>
using namespace std;
/*定义厨师类及派生类*/
class Chef {											//厨师类
	string name;
public:
	Chef(const string& na):name(na){}
	string getName() { return name; }					//获得名称
	virtual void make_food() {};						//虚方法,做食物
}; 

class Cake_division :public Chef {						//蛋糕师类
public:
	Cake_division(const string& st) :Chef(st) {}
	void make_cake() { cout << getName()<<"做蛋糕" << endl; }
	virtual void make_food(){ make_cake(); }
};

class Barista :public Chef {							//咖啡师类
public:
	Barista(const string& st) :Chef(st) {}
	void make_coffee() { cout << getName() << "冲咖啡" << endl; }
	virtual void make_food() { make_coffee(); }
};

class Guilinggao_master :public Chef {					//龟苓膏师傅类
public:
	Guilinggao_master(const string& st) :Chef(st){}
	void make_Guilinggao() { cout << getName() << "做龟苓膏" << endl; }
	virtual void make_food() { make_Guilinggao(); }
};

class Herbal_tea_master :public Chef {					//凉茶师傅类
public:
	Herbal_tea_master(const string& st) :Chef(st) {}
	void make_Herbal_tea() { cout << getName() << "做凉茶" << endl; }
	virtual void make_food() { make_Herbal_tea(); }
};

/*以下为单组食物适配器定义的类*/
class SingleGroup {										//单组接口
	string name;
public:
	SingleGroup(const string& st):name(st) {}
	virtual void eat() {};
};

class ChineseTeaGroup :public SingleGroup{				//中式下午茶类
	Guilinggao_master& gm;
	Herbal_tea_master& hm;
public:
	ChineseTeaGroup(Guilinggao_master& g, Herbal_tea_master& h, const string& st):gm(g),hm(h), SingleGroup(st){}
	void eat() { gm.make_food(); hm.make_food(); }
};

class WestTeaGroup :public SingleGroup {				//西式下午茶类
	Cake_division& cd;
	Barista& ba;
public:
	WestTeaGroup(Cake_division& c, Barista& b, const string& st):cd(c),ba(b),SingleGroup(st){}
	void eat() { cd.make_food(); ba.make_food(); }
};

/*以下为混合食物适配器定义的类*/
/*不想使用多重继承,用包含把厨师对象拿过来*/
class MixChineseTeaGroup {								//中式下午茶(混合)类
	string name;
public:
	MixChineseTeaGroup(const string& st):name(st){}
	virtual void eat(){}
};

class MixGuilinggao:public MixChineseTeaGroup {			//龟苓膏(混合)类
	Guilinggao_master& gm;
public:
	MixGuilinggao(Guilinggao_master& g,const string& st) :gm(g) ,MixChineseTeaGroup(st){}
	void eat() { gm.make_food();  }
};

class MixHerbal :public MixChineseTeaGroup {			//凉茶(混合)类
	Herbal_tea_master& hm;;
public:
	MixHerbal(Herbal_tea_master& h, const string& st) :hm(h), MixChineseTeaGroup(st) {}
	void eat() { hm.make_food(); }
};

class MixChineseDouble :public MixChineseTeaGroup {		//中式下午茶两个一起类
	Guilinggao_master& gm;
	Herbal_tea_master& hm;
public:
	MixChineseDouble(Guilinggao_master& g, Herbal_tea_master& h, const string& st) :gm(g), hm(h), MixChineseTeaGroup(st) {}
	void eat() { gm.make_food(); hm.make_food(); }
};


class MixWestTeaGruop {									//西式下午茶(混合)总类
	string name;
public:
	MixWestTeaGruop(const string& st) :name(st) {}
	virtual void eat() {}
};

class MixCake :public MixWestTeaGruop {					//蛋糕类(混合)						
	Cake_division& cn;
public:
	MixCake(Cake_division& c, const string& st):cn(c),MixWestTeaGruop(st){}
	void eat() { cn.make_food(); }
};

class MixBarista :public MixWestTeaGruop {				//咖啡类(混合)
	Barista& ba;
public:
	MixBarista(Barista& b, const string& st) :ba(b), MixWestTeaGruop(st) {}
	void eat() { ba.make_food(); }
};

class MixWestDouble :public MixWestTeaGruop {			//西式下午茶两个一起类
	Cake_division& cd;
	Barista& ba;
public:
	MixWestDouble(Cake_division& c, Barista& b, const string& st) :cd(c), ba(b), MixWestTeaGruop(st) {}
	void eat() { cd.make_food(); ba.make_food(); }
};

 接口和适配器类.cpp

/*适配器及接口定义*/
#include<iostream>
#include<string>
#include"接口和适配器.h"
using namespace std;

//抽象基类(接口)定义
class Abs_AfternoonTea {
public:
	virtual void	eat() = 0;							//纯虚方法:功能需求
};

//单组适配器定义
class SingleGroup_Adapter :public Abs_AfternoonTea {
	SingleGroup& sg;
public:
	SingleGroup_Adapter(SingleGroup& s):sg(s){}
	virtual void eat() { sg.eat(); }
};

//混组适配器定义
class MixGroup_Adapter :public Abs_AfternoonTea {
	MixChineseTeaGroup& mcg;
	MixWestTeaGruop& mwg;
public:
	MixGroup_Adapter(MixChineseTeaGroup& mc, MixWestTeaGruop& mw):mcg(mc),mwg(mw){}
	virtual void eat() { mcg.eat(); mwg.eat(); }
};

//单点适配器定义
class SingleFood_Adapter :public Abs_AfternoonTea {
	Chef& cf;
public:
	SingleFood_Adapter(Chef& c):cf(c){}
	virtual void eat() { cf.make_food(); }
};

        测试代码        

int main(void) {
	/*单吃蛋糕*/
	 Cake_division cd("小张");								//生成蛋糕师对象
//	 Chef& cf = cd;											//厨师对象生成
	 SingleFood_Adapter sfa(cd);							//单点适配器对象生成
	 Abs_AfternoonTea& aat = sfa;							//转向接口
	 aat.eat();
	 cout << "===============分隔线============" << endl;

	/*中式下午茶组*/
	 Guilinggao_master xw("小王");
	 Herbal_tea_master xl("小李");
	 ChineseTeaGroup cg(xw, xl,"中式下午茶");
	 SingleGroup& sg = cg;
	 SingleGroup_Adapter sa = SingleGroup_Adapter(cg);		//单组适配器对象生成
	 Abs_AfternoonTea& aat1 = sa;							//转向接口
	 aat1.eat();
	 cout << "===============分隔线============" << endl;

	 /*混合下午茶*/
	 MixChineseDouble md(xw, xl,"混合下午茶");
	 MixChineseTeaGroup& mtg = md;
	 MixCake mc(cd, "xiaozhang");
	 MixWestTeaGruop& mg = mc;
	 MixGroup_Adapter ma = MixGroup_Adapter(mtg, mg);		//混合适配器对象生成
	 Abs_AfternoonTea& aat2 = ma;							//转向接口
	 aat2.eat();
}

================================内容分割线================================ 

         代码有打磨空间,一是能否去掉不相关的属性;二是引入客户指令---测试是自己写的条件,客户指令处理可以加进来

================================内容分割线================================ 

代码说明

        第一,看见密密麻麻的代码,为了一个小问题增加许多是否值得?

                代码多,但是表达的意思并不是很多,只是看起来多而已.

                值得不值得,这个得根据需求来.只要能满足客户需求就是值得的. 

        第二,可以实现哪些功能?

                1.单个组合:西式下午茶--咖啡和蛋糕套餐  (或)

                                   中式下午茶--龟苓膏和凉茶套餐

                2.混合点餐:咖啡,蛋糕,龟苓膏,凉茶任选其二以上(单点不行)

                3.单点:咖啡,蛋糕,龟苓膏,凉茶任选其一.

         第三,为什么有感觉重复的类?

                笔者暂时不会多重继承,也不知道多重继承是否适合.所以定义了多个类.测试可以的

关于适配器模式

        在接口--实现的过程中,加了适配器一层.适配器的作用简单描述就是继承接口,包含相关类 

        此外,适配器模式容易扩展.比如在此代码基础上,继续用适配器扩展,加入更多功能,也是很方便的.