工厂模式，策略模式，适配器模式

今天一下介绍三种设计模式，这样面试的时候就不怕被问了！

首先是工厂模式，工厂模式分为简单工厂模式，工厂方法模式，抽象工厂模式；

1，简单工厂模式，他的主要的特点是需要在工厂中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。

以怪兽来做例子：   

enum MonsterType {MonsterTypeA, MonsterTypeB};class Monster{public:    virtual void Move() = 0;};//怪兽Aclass MonsterA: public Monster{public:    void Move() { cout<<"MonsterA"<<endl; }};//怪兽Bclass MonsterB: public Monster{public:    void Move() { cout<<"MonsterB"<<endl; }};//唯一的工厂，可以根据判断生成不同的类型的怪兽class Factory{public:    Monster* CreateSingleCore(enum MonsterType type)    {        if(type == MonsterTypeA) //工厂内部判断            return new MonsterA(); //生产核A        else if(type == MonsterTypeB)            return new MonsterB(); //生产核B        else            return NULL;    }};

但是这样又会出现一个问题：当增加新的怪兽类型的时候，就要修改怪兽类，这违背了开放封闭原则；

于是，工厂方法模式出现，即定义一个用于创建对象的接口，让子类去决定实例化一个类，Factory Method使一个类的实例化延迟到子类；

看代码：

enum MonsterType {MonsterTypeA, MonsterTypeB};class Monster{public:    virtual void Move() = 0;};//怪兽Aclass MonsterA: public Monster{public:    void Move() { cout<<"MonsterA"<<endl; }};//怪兽Bclass MonsterB: public Monster{public:    void Move() { cout<<"MonsterB"<<endl; }};//唯一的工厂，可以根据判断生成不同的类型的怪兽class Factory{public:    virtual Monster* CreateSingleCore() = 0;};//生产怪兽a的工厂class FactoryA: public Factory{public:    MonsterA* CreateSingleCore() { return new MonsterA; }};//生产怪兽b的工厂class FactoryB: public Factory{public:    MonsterB* CreateSingleCore() { return new MonsterB; }};

但是说工厂方法模式也是有缺点的：当你没增加一种怪兽的时候，就需要增加一个对应的怪兽的工厂，相比于前面的简单工厂模式，工厂方法模式需要更多的类定义；

最后一个：抽象工厂模式，它的定义为提供一个创建一系列相关或相互依赖对象的接口，而无需制定他们具体的类；

看代码：

//第1种怪兽class FirstMonster{public:    virtual void Show() = 0;};class FirstMonsterA: public FirstMonster{public:    void Show() { cout<<"FirstMonsterA"<<endl; }};class FirstMonsterB :public FirstMonster{public:    void Show() { cout<<"FirstMonsterB"<<endl; }};//第2种怪兽class SecondMonster{public:    virtual void Show() = 0;};class SecondMonsterA : public SecondMonster{public:    void Show() { cout<<"SecondMonsterA"<<endl; }    };class SecondMonsterB : public SecondMonster{public:    void Show() { cout<<"SecondMonsterB"<<endl; }};//工厂class CoreFactory{public:    virtual FirstMonster* CreateFirstMonster() = 0;    virtual SecondMonster* CreateSecondMonster() = 0;};//工厂A，专门用来生产A类型的怪兽class FactoryA :public CoreFactory{public:    FirstMonster* CreateFirstMonster() { return new FirstMonsterA(); }    SecondMonster* CreateSecondMonster() { return new SecondMonsterA(); }};//工厂B，专门用来生产B类型的怪兽class FactoryB : public CoreFactory{public:    FirstMonster* CreateFirstMonster() { return new FirstMonsterB(); }    SecondMonster* CreateSecondMonster() { return new SecondMonsterB(); }};

从别处抠的图：

简单工厂模式的UML图：

工厂方法模式的UML图：

抽象工厂模式的UML图

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－华丽的分割线－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

现在介绍第2种：策略模式

其指的是定义一系列的算法，把它们一个个的封装起来，并且使他们可相互替换，

//抽象接口class Monster{public:    virtual void Move() = 0;};//三种具体的怪兽class MonsterA: public Monster{public:    void Move() { cout<<"MonsterA"<<endl; }};class MonsterB : public Monster{public:    void Move() { cout<<"MonsterB"<<endl; }};class MonsterC: public Monster{public:    void Move() { cout<<"MonsterC"<<endl; }};

已经定义好了怪兽的类型，关键在于怎么指定对应的怪兽；

这里首先的第一种办法就是：直接通过参数指定，传入一个特定的怪兽的指针。

看代码：

//获取到怪兽class GetMonster{private:    Monster *m_monster;public:    GetMonster(Monster *mon) { m_monster = mon; }    ~GetMonster() { delete m_monster; }    void Move() { m_monster->Move(); }};int main(){    GetMonster get(new MonsterA()); //暴露了所选择怪兽的定义    get.Move();    return 0;}

第一种方法暴露了太多的细节；下面看第2种方法，也是直接通过参数指定，只不过不是传入指针，而是一个标签，也就是怪兽对应的类型，不需要知道怪兽的定义；

看代码：

//怪兽的类型enum MonsterType {MonsterTypeA, MonsterTypeB, MonsterTypeC}; //标签class GetMonster{private:    Monster *m_monster;public:    GetMonster(enum MonsterType type)    {        if(type == MonsterTypeA)            m_monster = new MonsterA();        else if(type == MonsterTypeB)            m_monster = new MonsterB();        else if(type == MonsterTypeC)            m_monster = new MonsterC();        else            m_monster = NULL;    }    ~GetMonster() { delete m_monster; }    void Move() { m_monster->Move(); }};int main(){    GetMonster get(MonsterTypeA); //指定标签即可    get.Move();    return 0;}

上面的构造函数都需要行参，下面给出第三种实现，用模版；

通过模版的实参指定，在策略模式中，参数的传递无法避免，客户必须制定某种怪兽；

template <class RA>class GetMonster{private:    RA m_monster;public:    GetMonster() { }    ~GetMonster() { }    void Move() { m_monster->Move(); }};int main(){    GetMonster<MonsterA> get; //模板实参    get.Move();    return 0;}

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－华丽的分割线－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

下面介绍第三种模式：适配器模式

适配器模式将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能在一起工作的那些类可以一起工作，它包括类适配器和对象适配器，本文针对的是对象适配器。举例来说，在STL中的双端队列扮演着适配器的角色，队列用到了他的后端插入，前端删除；而栈则用到了他的后端插入，后端删除；

就以双端队列来讲，看代码：

//双端队列class Deque{public:void push_back(int x) { cout<<"Deque push_back"<<endl; }void push_front(int x) { cout<<"Deque push_front"<<endl; }void pop_back() { cout<<"Deque pop_back"<<endl; }void pop_front() { cout<<"Deque pop_front"<<endl; }};//顺序容器class Sequence{public:virtual void push(int x) = 0;virtual void pop() = 0;};//栈class Stack: public Sequence{public:void push(int x) { deque.push_back(x); }void pop() { deque.pop_back(); }private:Deque deque; //双端队列};//队列class Queue: public Sequence{public:void push(int x) { deque.push_back(x); }void pop() { deque.pop_front(); }private:Deque deque; //双端队列};

int main(){Sequence *s1 = new Stack();Sequence *s2 = new Queue();s1->push(1); s1->pop();s2->push(1); s2->pop();delete s1; delete s2;return 0;}

ok，到这里就介绍结束了，想看后面的设计模式请关注我后面的博客，谢谢！！！