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

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

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

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

以怪兽来做例子：   

enum MonsterType {MonsterTypeA, MonsterTypeB};
class Monster
{
public:
    virtual void Move() = 0;
};
//怪兽A
class MonsterA: public Monster
{
public:
    void Move() { cout<<"MonsterA"<<endl; }
};
//怪兽B
class 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;
};
//怪兽A
class MonsterA: public Monster
{
public:
    void Move() { cout<<"MonsterA"<<endl; }
};
//怪兽B
class 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，到这里就介绍结束了，想看后面的设计模式请关注我后面的博客，谢谢！！！