设计模式基础

单一职责原则：

就一个类而言，应该仅有一个引起它变化的原因。 如果一个类承担的职责过多，就等于把这些职责耦合在一起， 一个职责的变化可能会削 弱或者抑制这个类完成其它职责能力。这种耦合会导制脆弱的设计，当变化发生时，设计会 遭受到意想不到的破坏

如果你能够想到多于一个的动机去改变一个类，那么这个类就具有多于一个的职责

开放――封闭原则：
软件实体可以扩展，但是不可修改。即对于扩展是开放的，对于修改是封闭的。面 对需求，对程序的改动是通过增加代码来完成的，而不是改动现有的代码。 当变化发生时，我们就创建抽象来隔离以后发生同类的变化。 开放――封闭原则是面向对象的核心所在。 开发人员应该对程序中呈现出频繁变化 的那部分做出抽象，拒绝对任何部分都刻意抽象及不成熟的抽象

里氏代换原则：

一个软件实体如果使用的是一个父类的话，那么一定适用其子类。而且它察觉不出 父类对象和子类对象的区别。也就是说：在软件里面，把父类替换成子类，程序的行为没有 变化。 子类型必须能够替换掉它们的父类型

依赖倒转原则：

抽象不应该依赖细节，细节应该依赖抽象。即针对接口编程，不要对实现编程。 高层模块不能依赖低层模块，两者都应依赖抽象。 依赖倒转原则是面向对象的标志，用哪种语言编写程序不重要，如果编写时考虑的 是如何针对抽象编程而不是针对细节编程，即程序的所有依赖关系都终止于抽象类或接口。 那就是面向对象设计，反之那就是过程化设计

迪米特法则：

如果两个类不直接通信，那么这两个类就不应当发生直接的相互作用。如果 一个类需要调用另一个类的某个方法的话，可以通过第三个类转发这个调用。 在类的结构设计上，每一个类都应该尽量降低成员的访问权限。 该法则在后面的适配器模式、解释模式等中有强烈的体现 

简单工厂模式：

主要用于接口选择。新添加类时，不会影响以前的系统代码。核心思想是用一个工厂来根据输入的条件产生不同的类，然后根据不同类的 virtual 函数得到不同的结果

优点：提高了代码的可拓展性

缺点：1、每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。2、不遵循开放——封闭原则，添加产品类时需要修改工厂类

使用场景： 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 3、设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口。

注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

代码：

#include <iostream>
using namespace std;

//抽象基类
class Shape {
public:
    virtual void draw() const = 0;
    virtual ~Shape() = default;
};

//需要创建实体的类
class Rectangle : public Shape {
public:
    void draw() const {
        cout << "creat a Rectangle!" << endl;
    }
};

class Square : public Shape{
public:
    void draw() const {
        cout << "creat a Square!" << endl;
    }
    
};

class Circle : public Shape{
public:
    void draw() const {
        cout << "creat a Circle!" << endl;
    }
};

//工厂类
class ShapeFactory {
public:
    static Shape* Creat(const string&);//根据string参数来创建想要的类实体
    //不创建工厂类实体，在用户代码中直接通过域作用符调用该静态成员
};

Shape* ShapeFactory::Creat(const string &s) {
    if(s == "Rectangle") return new Rectangle();
    if(s == "Square") return new Square();
    if(s == "Circle") return new Circle();
}

int main(void) {
    //通过工厂类来创建我们想要的类型实体
    Shape *q1 = ShapeFactory::Creat("Circle");
    q1->draw();
    Shape *q2 = ShapeFactory::Creat("Rectangle");
    q2->draw();
    Shape *q3 = ShapeFactory::Creat("Square");
    q3->draw();

    delete q1;
    delete q2;
    delete q3;

// 输出：
// creat a Circle!
// creat a Rectangle!
// creat a Square!

    return 0;
}

策略模式：

定义算法家族，分别封装起来，让它们之间可以互相替换，让算法变化，不会影响到用户。根据绑定的动态类型不一样调用不同的算法

优点： 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好

缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露

使用场景： 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中选择一种。 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题

策略模式和简单工厂基本相同，但简单工厂模式只能解决对象创建问题，对于经常变动的算法应使用策略模式

代码：

#include <iostream>
using namespace std;

//策略基类
class Operation{
public:
    virtual doOperation(const int&, const int&) const = 0;
    virtual ~Operation() = default;
};

class AddOperation : public Operation{
public:
    doOperation(const int &a, const int &b) const {
        return a + b;
    }
};

class SubstractOperation : public Operation{
public:
    doOperation(const int &a, const int &b) const {
        return a - b;
    }
};

class MultiplyOperation : public Operation{
public:
    doOperation(const int &a, const int &b) const {
        return a * b;
    }
};

//创建 Context 类
class Context{
private:
    Operation *op;

public:
    Context(Operation *tmp) : op(tmp) {}
    int GetResult(const int &a, const int &b) const {
        op->doOperation(a, b);
    }

    ~Context() {
        delete op;
    }
    
};

int main(void) {
    Context c1(new AddOperation());
    Context c2(new SubstractOperation());
    Context c3(new MultiplyOperation());

    //根据绑定的动态类型不一样调用不同的算法
    cout << c1.GetResult(1, 1) << endl;//2
    cout << c2.GetResult(1, 1) << endl;//0
    cout << c3.GetResult(1, 1) << endl;//1

    return 0;
}

策略与工厂结合：

同时集合了简单工厂模式的选择接口功能以及策略模式的自由选择算法的功能

#include <iostream>
using namespace std;

//策略基类
class Operation{
public:
    virtual doOperation(const int&, const int&) const = 0;
    virtual ~Operation() = default;
};

class AddOperation : public Operation{
public:
    doOperation(const int &a, const int &b) const {
        return a + b;
    }
};

class SubstractOperation : public Operation{
public:
    doOperation(const int &a, const int &b) const {
        return a - b;
    }
};

class MultiplyOperation : public Operation{
public:
    doOperation(const int &a, const int &b) const {
        return a * b;
    }
};

//创建 Context 类
class Context{
private:
    Operation *op;

public:
    Context(const string &s){
        if(s == "AddOperation") op = new AddOperation();
        else if(s == "SubstractOperation") op = new SubstractOperation();
        else op = new MultiplyOperation();
    }
    int GetResult(const int &a, const int &b) const {
        op->doOperation(a, b);
    }

    ~Context() {
        delete op;
    }
    
};

int main(void) {
    //通过 string 参数选择我们想创建的类
    Context c1("AddOperation");
    Context c2("SubstractOperation");
    Context c3("MultiplyOperation");

    //根据绑定的动态类型不一样调用不同的算法
    cout << c1.GetResult(1, 1) << endl;//2
    cout << c2.GetResult(1, 1) << endl;//0
    cout << c3.GetResult(1, 1) << endl;//1

    return 0;
}

装饰器模式：

装饰模式就是把要添加的附加功能分别放在单独的类中，并让这个类包含它要装饰的对象，当需要执行时，客户端就可以有选择地、按顺序地使用装饰功能包装对象。可以在不想增加很多子类的情况下拓展类的功能

优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。可以避免随着扩展功能的增多，子类膨胀的情况

缺点：多层装饰比较复杂

使用场景： 1、扩展一个类的功能。 2、动态增加功能，动态撤销。

注意事项：可代替继承

代码：

#include <iostream>
#include <string>
using namespace std;

//原对象抽象基类
class Cake{
public:
    Cake() : name("Cake") {}
    virtual void showCake() = 0;
    virtual ~Cake() = default;
    std::string name;
};

//原对象具体类
class ConcreteCake : public Cake{
public:
    //注意: 继承自基类的成员必须通过基类的默认构造函数或构造函数初始化
    ConcreteCake() : Cake() {}
    ~ConcreteCake() = default;
    void showCake() {
        cout << name << endl;
    }
};

//装饰器抽象基类
class CakeDecrator : public Cake{
protected:
    Cake *pCake;

public:
    CakeDecrator(Cake *nCake) : pCake(nCake) {}
    virtual void showCake() = 0;
    virtual ~CakeDecrator() = default;
};

//具体装饰类
class CakeDecratorMilk : public CakeDecrator{
public:
    CakeDecratorMilk(Cake *nCake) : CakeDecrator(nCake) {}
    void showCake() {
        name = pCake->name + " Milk";
        cout << name << endl;
    }
};

class CakeDecratorCholate : public CakeDecrator{
public:
    CakeDecratorCholate(Cake *nCake) : CakeDecrator(nCake) {}
    void showCake() {
        name = pCake->name + " Cholate";
        cout << name << endl;
    }
    
};

int main(void) {
    ConcreteCake *cCake = new ConcreteCake();
    cCake->showCake();

    CakeDecratorMilk *mCake = new CakeDecratorMilk(cCake);
    mCake->showCake();

    CakeDecratorCholate *hCake = new CakeDecratorCholate(mCake);
    hCake->showCake();

    delete cCake;
    delete mCake;
    delete hCake;

    return 0;
}

代理模式：

为其他对象提供一种代理以控制对这个对象的访问。解决在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

优点： 1、职责清晰。 2、高扩展性。 3、智能化。

缺点： 1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

使用场景：按职责来划分，通常有以下使用场景： 1、远程代理。 2、虚拟代理。 3、Copy-on-Write 代理。 4、保护（Protect or Access）代理。 5、Cache代理。 6、防火墙（Firewall）代理。 7、同步化（Synchronization）代理。 8、智能引用（Smart Reference）代理

注意事项： 1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。 2、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制

代码：

#include <iostream>
using namespace std;

//定义接口
class Interface {
public:
    virtual void Request() = 0;
};

//真实类
class RealClass : public Interface{
public:
    virtual void Request() {
        cout << "real quest" << endl;
    }
};

//代理类
class ProxyClass : public Interface{
private:
    RealClass *rclass;
public:
    virtual void Request() {
        rclass = new RealClass();
        rclass->Request();
        delete rclass;
    }
};

int main(void) {
    //看起来我们在访问ProxtClass类，但实际上在访问ProxtClass类
    ProxyClass *test = new ProxyClass();
    test->Request();
    return 0;
}

工厂方法模式：

修正了简单工厂模式中不遵守开放－封闭原则。

工厂方法模式基本与简单工厂模式差不多，但每次添加一个产品子类都必须在工厂类中添加一个判断分支，这样违背了开放-封闭原则。工厂模式就是为了解

代码：

#include <iostream>
using namespace std;

//抽象基类
class Shape {
public:
    virtual void draw() const = 0;
};

//需要创建实体的类
class Rectangle : public Shape {
public:
    void draw() const {
        cout << "creat a Rectangle!" << endl;
    }
};

class Square : public Shape{
public:
    void draw() const {
        cout << "creat a Square!" << endl;
    }
    
};

class Circle : public Shape{
public:
    void draw() const {
        cout << "creat a Circle!" << endl;
    }
};

//工厂基类
class ShapeFactory {
public:
    virtual Shape* Creat() = 0;//根据动态绑定创建想要的类
    virtual ~ShapeFactory() = default;
};

//具体工厂类
class FactoryCircle : public ShapeFactory{
public:
    Shape* Creat() {
        return new Circle();
    }
};

class FactoryRectangle : public ShapeFactory{
public:
    Shape* Creat() {
        return new Rectangle();
    }
};

class FactorySquare : public ShapeFactory{
public:
    Shape* Creat() {
        return new Square();
    }
};

int main(void) {
    //通过工厂类来创建我们想要的类型实体
    ShapeFactory *cnt1 = new FactoryCircle();
    ShapeFactory *cnt2 = new FactoryRectangle();
    ShapeFactory *cnt3 = new FactorySquare();
    Shape *q1 = cnt1->Creat();
    q1->draw();
    Shape *q2 = cnt2->Creat();
    q2->draw();
    Shape *q3 = cnt3->Creat();
    q3->draw();

    delete cnt1;
    delete cnt2;
    delete cnt3;
    delete q1;
    delete q2;
    delete q3;

// 输出：
// creat a Circle!
// creat a Rectangle!
// creat a Square!

    return 0;
}

原型模式：

原型模式的行为类似于拷贝构造函数，但并不等同于拷贝构造函数。拷贝构造函数生成的新对象只能是类本身。原型模式是描述了一个通用方法(或概念)，它不管是如何实现的，而拷贝构造则是描述了一个具体实现方法。

Prototype 的意义在于，你拿到一个 Base* ，它指向某个 Derived 对象，你想克隆出 Derived 对象，但代码中不写出 Derived 的具体类型，因为有很多派生类，不知道 Base 的动态类型是什么，这种情况下你用构造函数是搞不定的

代码：

#include <iostream>
using namespace std;

class Prototype {
private:
    string name;

public:
    Prototype(string s = "") : name(s) {}
    virtual ~Prototype() = default;
    virtual Prototype* Clone() {
        cout << "clone Prototype" << endl;
        return new Prototype(*this);
    }
    void Show() const{
        cout << name << endl;
    }
};

class ConcretePrototype1 : public Prototype{
public:
    ConcretePrototype1(string s = "") : Prototype(s) {}
    ConcretePrototype1* Clone() override {
        cout << "clone ConcretePrototype1" << endl;
        return new ConcretePrototype1(*this);
    }
}; 

class ConcretePrototype2 : public Prototype{
public:
    ConcretePrototype2(string s = "") : Prototype(s) {}
    ConcretePrototype2* Clone() override {
        cout << "clone ConcretePrototype2" << endl;
        return new ConcretePrototype2(*this);
    }
}; 

class ConcretePrototype3 : public Prototype{
public:
    ConcretePrototype3(string s = "") : Prototype(s) {}
    ConcretePrototype3* Clone() override {
        cout << "clone ConcretePrototype3" << endl;
        return new ConcretePrototype3(*this);
    }
}; 

int main(void) {
    Prototype *p1 = new ConcretePrototype1();
    //假设我们此时并不知道 p1 的动态类型，显然我们不能使用拷贝构造函数，但我们可以通过原型模型构建一个值等同于p1所指对象的对象
    Prototype *p2 = p1->Clone();//clone ConcretePrototype1
    return 0;
}

模板方法模式：

定义一个操作中的算法骨架，而将一些步骤延迟到子类中实现。模板方法使得子类可以再不改变一个算法的结构即可重新定义该算法的某些特定步骤。通过把不变的行为搬移到基类中，去除了子类的重复代码，提供了一个很好的代码复用解决方案

模板方法是将原来不变的行为和可变的行为剥离开，将不变的行为剥离到基类中，由基类提供一个模板方法，模板方法设置了算法的骨架，而各家的各个实现步骤和细节由各个子类具体实现

优点： 1、封装不变部分，扩展可变部分。 2、提取公共代码，便于维护。 3、行为由父类控制，子类实现。

缺点：每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。

使用场景： 1、有多个子类共有的方法，且逻辑相同。 2、重要的、复杂的方法，可以考虑作为模板方法。3、重构时，经常使用的方案，将相同的代码抽象到父类，通过钩子函数约束行为

样例1：

#include <iostream>
using namespace std;

class Game{
protected:
    virtual void initialize() const = 0;
    virtual void startPlay() const = 0;
    virtual void endPlay() const = 0;

public:
    void play() { //模板方法
        initialize();//初始化游戏
        startPlay();//开始游戏
        endPlay();//结束游戏
    }
    virtual ~Game() = default;
};

class Cricket : public Game{
protected:
    void initialize() const override {
        cout << "Cricket Game initialize." << endl;
    }
    void startPlay() const override {
        cout << "Cricket Game startPlay." << endl;
    }
    void endPlay() const override {
        cout << "Cricket Game endPlay." << endl;
    }
};

class Football : public Game{
protected:
    void initialize() const override {
        cout << "Football Game initialize." << endl;
    }
    void startPlay() const override {
        cout << "Football Game startPlay." << endl;
    }
    void endPlay() const override {
        cout << "Football Game endPlay." << endl;
    }
};

int main(void) {
    Game *game1 = new Cricket();
    game1->play();
    cout << endl;

    Game *game2 = new Football();
    game2->play();

// 输出：
// Cricket Game initialize.
// Cricket Game startPlay.
// Cricket Game endPlay.

// Football Game initialize.
// Football Game startPlay.
// Football Game endPlay.

    return 0;
}

样例2：

#include <iostream>
using namespace std;

class test{
private:
    problemOne() const {
        cout << "1 + 1 = ?" << endl;
    }
    problemTwo() const {
        cout << "1 * 1 = ?" << endl;
    }

protected:
    virtual void studentName() const = 0;
    virtual void answerOne() const = 0;
    virtual void answerTwo() const = 0;

public:
    doTest() const {//模板方法
        studentName();
        problemOne();
        answerOne();
        problemTwo();
        answerTwo();
    }

    virtual ~test() = default;
};

class XiaoHongTestPaper : public test {
protected:
    void studentName() const override {
        cout << "XiaoHong" << endl;
    }
    void answerOne() const override {
        cout << "10" << endl;
    }
    void answerTwo() const override {
        cout << "1" << endl;
    }
};

class XiaoFangTestPaper : public test {
protected:
    void studentName() const override {
        cout << "XiaoFang" << endl;
    }
    void answerOne() const override {
        cout << "3" << endl;
    }
    void answerTwo() const override {
        cout << "1" << endl;
    }
};

int main(void) {
    test *student1 = new XiaoFangTestPaper();
    student1->doTest();

    cout << endl;

    test *student2 = new XiaoHongTestPaper();
    student2->doTest();

// 输出：
// XiaoFang
// 1 + 1 = ?
// 3
// 1 * 1 = ?
// 1

// XiaoHong
// 1 + 1 = ?
// 10
// 1 * 1 = ?
// 1

    return 0;
}

外观模式：

外观模式隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性，这个接口使得这一子系统更加容易使用

优点： 1、减少系统相互依赖。 2、提高灵活性。 3、提高了安全性。

缺点：不符合开闭原则，如果要改东西很麻烦，继承重写都不合适。

代码：

#include <iostream>
using namespace std;

class SubSys{
public:
    SubSys() = default;
    virtual ~SubSys() = default;
    
    virtual void Method() const = 0;
};

class SubSysOne : public SubSys {
public:
    void Method() const override {
        cout << "the first way" << endl;
    }
    
};

class SubSysTwo : public SubSys {
public:
    void Method() const override {
        cout << "the twoth way" << endl;
    }
    
};

class SubSysThree : public SubSys {
public:
    void Method() const override {
        cout << "the Third way" << endl;
    }
    
};

//外观类
class Facade {
private:
    SubSysOne *sub1;
    SubSysTwo *sub2;
    SubSysThree *sub3;

public:
    Facade() : sub1(new SubSysOne()), sub2(new SubSysTwo()), sub3(new SubSysThree) {}
    ~Facade() {
        delete sub1;
        delete sub2;
        delete sub3;
    }
    
    void FacadeMethod() const {
        sub1->Method();
        sub2->Method();
        sub3->Method();
    }

};

int main(void) {
    Facade test;
    test.FacadeMethod();

// 输出：
// the first way
// the twoth way
// the Third way

    return 0;
}

建造者模式：

在当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时适用

代码：

#include <iostream>
#include <list>
using namespace std;

class Packing;

//创建一个表示食物条目的接口
class Item {
public:
    virtual ~Item() = default;

    virtual string name() = 0;
    virtual Packing* packing() = 0;
    virtual float price() = 0;
};

// 创建一个表示食物包装的接口
class Packing {
public:
    virtual ~Packing() = default;

    virtual string pack() = 0;
};

//创建 Packing 派生类
class Wrapper : public Packing {
public:
    string pack() override {
        return "Wrapper";
    }
};

class Bottle : public Packing {
public:
    string pack() override {
        return "Bottle";
    }
};

//创建 Item 接口的抽象派生类
class Burger : public Item {
public:
    Packing* packing() override {
        return new Wrapper();
    }
};

class ColdDrink : public Item {
public:
    Packing* packing() override {
        return new Bottle();
    }
    
};

//创建扩展 Bugger 和 ColdDrink 的实体类
class VegBurger : public Burger{
public:
    float price() override {
        return 25.0f;
    }
    string name() {
        return "Veg Burger";
    }
};

class ChickenBurge : public Burger {
public:
    float price() override {
        return 50.5f;
    }
    string name() override {
        return "Chicken Burge";
    }

};

class Coke : public ColdDrink {
public:
    float price() override {
        return 30.0f;
    }
    string name() {
        return "Coke";
    }
};

class Pepsi : public ColdDrink {
public:
    float price() override {
        return 35.0f;
    }
    string name() override {
        return "Pepsi";
    }
};

//创建一个 Meal 类，带有上面的 Item 对象
class Meal {
private:
    list<Item*> items;

public:
    void addItem(Item *item) {
        items.push_back(item);
    }
    float getCost() {
        float cost = 0.0f;
        for(const auto &indx : items) {
            cost += indx->price();
        }
        return cost;
    }
    void showItems() {
        for(const auto &indx : items) {
            cout << "Item: " << indx->name();
            cout << ", packing: " << (indx->packing())->pack();
            cout << ", price: " << indx->price() << endl;
        }
    }

};

//创建一个 MealBuilder 类，实际的 builder 类负责创建 Meal 对象
class MealBuilder {
public:
    Meal prepareVegMeal() {
        Meal meal;
        meal.addItem(new VegBurger());
        meal.addItem(new Coke());
        return meal;
    }
    Meal prepareNonVegMeal() {
        Meal meal;
        meal.addItem(new ChickenBurge());
        meal.addItem(new Pepsi());
        return meal;
    }

};

int main(void) {
    MealBuilder m1;

    Meal vegMeal = m1.prepareVegMeal();
    cout << "Veg Meal" << endl;
    vegMeal.showItems();
    cout << "Total cost: " << vegMeal.getCost() << endl;
    cout << endl;

    Meal nonVegMeal = m1.prepareNonVegMeal();
    cout << "Non-Veg Meal" << endl;
    nonVegMeal.showItems();
    cout << "Total cost: " << nonVegMeal.getCost() << endl;

// 输出：
// Veg Meal
// Item: Veg Burger, packing: Wrapper, price: 25
// Item: Coke, packing: Bottle, price: 30
// Total cost: 55

// Non-Veg Meal
// Item: Chicken Burge, packing: Wrapper, price: 50.5
// Item: Pepsi, packing: Bottle, price: 35
// Total cost: 85.5

    return 0;
}

观察者模式：

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式

优点： 1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。

缺点： 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间

代码：

//观察者模式
#include <iostream>
#include <vector>
using namespace std;

//观察者接口
class Observer{
public:
    virtual void update(string msg) = 0;
};

//第一个观察者
class F_Observer : public Observer{
public:
    void update(string msg) override {
        cout << "F_Observer: " << msg << endl;
    }
};

//第二个观察者
class S_Observer : public Observer{
public:
    void update(string msg) override {
        cout << "S_Observer: " << msg << endl;
    }
};

//第三个观察者
class T_Observer : public Observer{
public:
    void update(string msg) override {
        cout << "T_Observer: " << msg << endl;
    }
};

//被观察者
class subject{
public:
    void setMsg(string msg) {
        notifyAll(msg);
    }

    //订阅
    void addAttach(Observer *observe) {
        observes.push_back(observe);
    }

private:
    vector<Observer*> observes;//存储订阅者的状态

    notifyAll(string msg) {//通知所有订阅的观察者
        for(const auto &indx : observes) {
            indx->update(msg);
        }
    }
};

int main(void) {
    F_Observer *f_Observer = new F_Observer();
    S_Observer *s_Observer = new S_Observer();
    T_Observer *t_Observer = new T_Observer();

    subject sb;
    sb.addAttach(f_Observer);
    sb.addAttach(s_Observer);
    sb.addAttach(t_Observer);

    sb.setMsg("msg has changed");

// 输出：
// F_Observer: msg has changed
// S_Observer: msg has changed
// T_Observer: msg has changed

    return 0;
}

抽象工厂模式：

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码

代码：

//抽象工厂模式
#include <iostream>
using namespace std;

//为形状创建一个接口
class Shape{
public:
    virtual void draw() = 0;
};

//创建实现形状接口的实体类
class Rectangel : public Shape{
public:
    void draw() override {
        cout << "inside Rectangel::draw() method." << endl;
    }
};

class Square : public Shape{
public:
    void draw() override {
        cout << "inside Square::draw() method." << endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        cout << "inside Circle::draw() method." << endl;
    }
};

//为颜色创建一个接口
class Color {
public:
    virtual void fill() = 0;
};

//实现颜色接口类
class Red : public Color{
public:
    void fill() override {
        cout << "inside Red::fill() method." << endl;
    }
};

class Green : public Color{
public:
    void fill() override {
        cout << "inside Green::fill() method." << endl;
    }
};

class Blue : public Color{
public:
    void fill() override {
        cout << "inside Blue::fill() method." << endl;
    }
};

//为Color和Shape创建抽象工厂类来获取工厂类
class AbstractFactory {
public:
    virtual Color* getColor(const string &color) = 0;
    virtual Shape* getShape(const string &shape) = 0;
};

//实现AbstractFactory的具体工厂类
class ShapeFactory : public AbstractFactory {
public:
    Shape* getShape(const string &shape) override {
        if(shape == "Circle") return new Circle();
        else if(shape == "Rectangel") return new Rectangel();
        else if(shape == "Square") return new Square();

        return NULL;
    }

    Color* getColor(const string &color) override {
        return NULL;
    }
};

class ColorFactory : public AbstractFactory {
public:
    Shape* getShape(const string &shape) override {
        return NULL;
    }

    Color* getColor(const string &color) override {
        if(color == "Red") return new Red();
        else if(color == "Blue") return new Blue();
        else if(color == "Green") return new Green();

        return NULL;
    }
};

//创建一个工厂生成器类，通过传递形状或颜色信息来获取对应工厂
class FactoryProducer {
public:
    static AbstractFactory* getFactory(const string &choice) {
        if(choice == "Shape") return new ShapeFactory();
        else if(choice == "Color") return new ColorFactory();

        return NULL;
    }
};


int main(void) {
    //获取形状工厂
    AbstractFactory *shape_f = FactoryProducer::getFactory("Shape");
    //获取形状为Circle的对象
    Shape *shape1 = shape_f->getShape("Circle");
    //调用Circle的draw方法
    shape1->draw();

    //获取形状为Rectangle的对象
    Shape *shape2 = shape_f->getShape("Rectangel");
    //调用Rectangle的draw方法
    shape2->draw();

    //获取形状为Square的对象
    Shape *shape3 = shape_f->getShape("Square");
    //调用Square的draw方法
    shape3->draw();

    //获取颜色工厂
    AbstractFactory *color_f = FactoryProducer::getFactory("Color");
    //获取颜色为Red的对象
    Color *col1 = color_f->getColor("Red");
    //调用Red的fill方法
    col1->fill();

    //获取颜色为Green的对象
    Color *col2 = color_f->getColor("Green");
    //调用Green的fill方法
    col2->fill();

    //获取颜色为Blue的对象
    Color *col3 = color_f->getColor("Blue");
    col3->fill();

    delete shape_f;
    delete shape1;
    delete shape2;
    delete shape3;
    delete color_f;
    delete col1;
    delete col2;
    delete col3;

    return 0;
// 输出：
// inside Circle::draw() method.
// inside Rectangel::draw() method.
// inside Square::draw() method.
// inside Red::fill() method.
// inside Green::fill() method.
// inside Blue::fill() method.
}

状态模式：

在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。

在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象

代码：

Context.h

#include <iostream>

class State;

//创建Context类
class Context {
private:
    State *sta;

public:
    Context() : sta(NULL) {}

    void setState(State *state) {
        this->sta = state;
    }

    State* getState() {
        return sta;
    }
};

Context.cpp

#include "Context.h"

状态类及测试代码

//状态模式
#include <iostream>
#include "Context.h"
using namespace std;

//创建一个接口
class State {
public:;
    virtual void doAction(Context *cont) = 0;
    virtual string toString() = 0;
};

//创建实习接口的具体类
class StartState : public State {
public:
    void doAction(Context *cont) override {
        cout << "player is in start state" << endl;
        cont->setState(this);
    }

    string toString() {
        return "start state";
    }
};

class StopState : public State {
public:
    void doAction(Context *cont) override {
        cout << "player is in stop state" << endl;
        // cont->setState(this);
    }

    string toString() {
        return "Stop State";
    }
};

//使用 Context 来查看当状态 State 改变时的行为变化

int main(void) {
    Context *cnt = new Context();

    StartState start;
    start.doAction(cnt);
    cout << cnt->getState()->toString() << endl;

    StopState stopt;
    stopt.doAction(cnt);
    cout << cnt->getState()->toString() << endl;

    delete cnt;

// 输出：
// player is in start state
// start state
// player is in stop state
// start state

    return 0;
}

适配器模式：

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。

这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。举个真实的例子，读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡

优点： 1、可以让任何两个没有关联的类一起运行。 2、提高了类的复用。 3、增加了类的透明度。 4、灵活性好。

缺点：过多地使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构

代码：

#include <iostream>
using namespace std;

//为媒体播放器和更高级的媒体播放器创建接口
class MediaPlayer {
public:
    virtual void play(const string &audioType, const string &fileName) = 0;
};

class AdvancedMediaPlayer {
public:
    virtual void playVlc(const string &fileName) = 0;
    virtual void playMp4(const string &fileName) = 0;
};

//创建实现了AdvancedMediaPlayer接口的实体类
class VlcPlayer : public AdvancedMediaPlayer {
public:
    void playVlc(const string &fileName) override {
        cout << "Playing vlc file. name: " << fileName << endl;
    }

    void playMp4(const string &fileName) override {
        //do nothing
    }
};

class Mp4Player : public AdvancedMediaPlayer {
public:
    void playVlc(const string &fileName) override {
        //do nothing
    }

    void playMp4(const string &fileName) override {
        cout << "Playing Mp4 file. name: " << fileName << endl;
    }
};

//创建MediaPlayer接口的适配器类
class MediaAdapter : public MediaPlayer {
private:
    AdvancedMediaPlayer *advanceMusicPlayer;

public:
    MediaAdapter(const string &audioType) {
        if(audioType == "vlc") advanceMusicPlayer = new VlcPlayer();
        else if(audioType == "mp4") advanceMusicPlayer = new Mp4Player();
    }
    
    void play(const string &audioType, const string &fileName) override {
        if(audioType == "vlc") advanceMusicPlayer->playVlc(fileName);
        else if(audioType == "mp4") advanceMusicPlayer->playMp4(fileName);
    }

};

//创建MediaPlayer接口的实体类
class AudioPlayer : public MediaPlayer {
private:
    MediaAdapter *mediaAdapter;

public:
    void play(const string &audioType, const string &fileName) override {
        //播放mp3音乐文件的内置支持
        if(audioType == "mp3") cout << "Playing mp3 file. name: " << fileName << endl;
        //mediaAdapter提供了播放其它音乐格式的支持
        else if(audioType == "vlc" || audioType == "mp4") {
            mediaAdapter = new MediaAdapter(audioType);
            mediaAdapter->play(audioType, fileName);
        }else cout << "Invalid media. " << audioType << " format not supported" << endl;
    }
};

int main(void) {
    //使用AudioPlayer来播放不同类型的音频格式
    AudioPlayer *audioPlayer = new AudioPlayer();

    audioPlayer->play("mp3", "beyond the horizon.mp3");
    audioPlayer->play("mp4", "alone.mp4");
    audioPlayer->play("vlc", "far far away.vlc");
    audioPlayer->play("avi", "mind me.avi");

// 输出：
// Playing mp3 file. name: beyond the horizon.mp3
// Playing Mp4 file. name: alone.mp4
// Playing vlc file. name: far far away.vlc
// Invalid media. avi format not supported

    delete audioPlayer;

    return 0;
}

备忘录模式：

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外 保存这个状态，这样就可以将以后的对象状态恢复到先前保存的状态。 适用于功能比较复杂的，但需要记录或维护属性历史的类；或者需要保存的属性只是众 多属性中的一小部分时 Originator 可以根据保存的 Memo 还原到前一状态

代码：

#include <iostream>
#include <vector>
using namespace std;

class Memento {
private:
    string state;

public:
    Memento(const string &s) : state(s) {}
    string getState() {
        return state;
    }
};

class Originator {
private:
    string state;

public:
    //设置状态
    void setState(const string &s) {
        state = s;
    }

    //返回当前状态
    string getState() {
        return state;
    }

    //保存当前状态到Memento中
    Memento* saveStateToMemento() {
        return new Memento(state);
    }

    //从Memento中取出保存的状态
    void getStateFromMemento(Memento *m) {
        state = m->getState();
    }
};

//创建管理者类
class CareTaker {
private:
    vector<Memento*> mementolist;

public:
    void add(Memento *state) {
        mementolist.push_back(state);
    }

    Memento* get(int indx) {
        return mementolist[indx];
    }
};

int main(void) {
    Originator ori;
    CareTaker car;

    ori.setState("State #1");//设置当前状态为State #1
    ori.setState("State #2");//设置当前状态为State #2(覆盖了前面的状态)

    car.add(ori.saveStateToMemento());//将ori的当前状态保存到Memento中
    ori.setState("State #3");
    car.add(ori.saveStateToMemento());
    ori.setState("State #4");

    cout << "Current State: " << ori.getState() << endl;//取出ori中的当前状态
    ori.getStateFromMemento(car.get(0));
    cout << "first saved State: " << ori.getState() << endl;
    ori.getStateFromMemento(car.get(1));
    cout << "second saved State: " << ori.getState() << endl;

// 输出：
// Current State: State #4
// first saved State: State #2
// second saved State: State #3

    return 0;
}    

组合模式：

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。

这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式

优点： 1、高层模块调用简单。 2、节点自由增加。

缺点：在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。

//组合模式
#include <iostream>
#include <sstream>
#include <vector>
using namespace std;

//创建Employee类，该类带有Employee对象的列表
class Employee {
private:
    string name;
    string dept;
    int salary;
    vector<Employee*> subordinates;

public:
    Employee(const string &na, const string &de, int sal) : name(na), dept(de), salary(sal) {}
    
    void add(Employee *e) {
        subordinates.push_back(e);
    }

    void remove(Employee *e) {
        vector<Employee*>::iterator it = subordinates.begin();
        while(it != subordinates.end() && (*it) != e) ++it;
        if(*it == e) subordinates.erase(it);
    }

    vector<Employee*> getSubordinates() {
        return subordinates;
    }

    string toString() {
        ostringstream os;
        os << salary;
        string ref = "";
        ref += name;
        ref += " ";
        ref += dept;
        ref += " ";
        ref += os.str();
        return ref;
    }
};

int main(void) {
    Employee *CEO = new Employee("john", "CEO", 30000);
    
    Employee *headSales = new Employee("Robert", "Head Sales", 20000);
    Employee *headMarketing = new Employee("Michel", "Head Marketing", 20000);

    Employee *clerk1 = new Employee("Laura", "Marketing", 10000);
    Employee *clerk2 = new Employee("Bob","Marketing", 10000);

    Employee *salesExecutive1 = new Employee("Richard","Sales", 10000);
    Employee *salesExecutive2 = new Employee("Rob","Sales", 10000);

    CEO->add(headSales);
    CEO->add(headMarketing);

    headSales->add(salesExecutive1);
    headSales->add(salesExecutive2);

    headMarketing->add(clerk1);
    headMarketing->add(clerk2);

    cout << CEO->toString() << endl;
    for(const auto &indx : CEO->getSubordinates()) {
        cout << indx->toString() << endl;
        for(const auto &j : indx->getSubordinates()) {
            cout << j->toString() << endl;
        }
    }

// 输出模式：
// john CEO 30000
// Robert Head Sales 20000
// Richard Sales 10000
// Rob Sales 10000
// Michel Head Marketing 20000
// Laura Marketing 10000
// Bob Marketing 10000

    return 0;
}

迭代器模式：

提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。可以提供不同的方式来遍历整个整合对象

优点： 1、它支持以不同的方式遍历一个聚合对象。 2、迭代器简化了聚合类。 3、在同一个聚合上可以有多个遍历。 4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码

缺点：由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性

代码：

//迭代器模式
#include <iostream>
#include <vector>
using namespace std;

//迭代器模板抽象基类
template<typename Iter>
class Iterator {
public:
    virtual Iter next() = 0;
    virtual bool hasNext() = 0;
};

//迭代器模板类
template<typename Iter>
class ConcreteIterator : public Iterator<Iter> {
private:
    vector<Iter> vec;
    int cursor = 0;

public:
    ConcreteIterator(vector<Iter> v) : vec(v) {}
    
    bool hasNext() override {
        if(cursor >= vec.size()) return false;
        return true;
    }

    Iter next() override {
        if(hasNext()) return vec[cursor++];
        return nullptr;
    }
};

//容器模板抽象基类
template<typename Iter>
class Aggregate {
public:
    virtual void add(Iter obj) = 0;
    virtual void remove(Iter obj) = 0;
    virtual Iterator<Iter>* iterator() = 0;
};

//容器模板类
template<typename Iter>
class ConcreteAggregate : public Aggregate<Iter> {
private:
    vector<Iter> vec;

public:
    void add(Iter obj) override {
        vec.push_back(obj);
    }

    Iterator<Iter>* iterator() override {
        return new ConcreteIterator<Iter>(vec);
    }

    void remove(Iter obj) override {
        auto it = vec.begin();
        while(it != vec.end() && (*it) != obj) ++it;
        if(*it == obj) vec.erase(it);
    }
};

int main(void) {
    Aggregate<string> *ag = new ConcreteAggregate<string>();
    ag->add("ge");
    ag->add("lou");
    ag->add("ting");
    ag->add("yu");

    Iterator<string> *it = ag->iterator();
    while(it->hasNext()) {
        cout << it->next() << endl;
    }

    return 0;
}

单例模式：

http://www.cnblogs.com/geloutingyu/p/8640492.html

桥接模式：

桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。这种类型的设计模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦。这种模式涉及到一个作为桥接的接口，使得实体类的功能独立于接口实现类。这两种类型的类可被结构化改变而互不影响。

通俗点来讲就是，比如我们要画个图形，它有两种属性，颜色和形状。如果使用继承来实现的话是这样的，先定义个图形的抽象基类，然后从图形类中派生出颜色类，再从每个颜色类中都派生出所有的形状。在这种实现中颜色和形状这两个维度不能彼此独立，看起来十分臃肿。

换个角度考虑，我们可以将颜色和形状设计成两个独立的继承体系，然后在形状继承体系中加入一个颜色抽象基类指针(反之也可)，然后在使用时我们只要创建形状对象并设置里面的颜色指针即可实现形状和颜色的任意组合。在这种实现中，由前面的三层继承体系变成了两层继承体系，减少了很多重复代码，并且颜色和形状可以独立拓展。

代码：

//桥接模式
#include <iostream>
using namespace std;

//创建桥接接口
class DrawAPI {
public:
    virtual void drawCircle(int radius, int x, int y) = 0;
    virtual ~DrawAPI() = default;
};

//创建DrawAPI桥接接口的实体类
class RedCircle : public DrawAPI {
public:
    void drawCircle(int radius, int x, int y) override {
        cout << "Drawing Circle[ color: red, radius: "
         << radius << ", x: " << x << ", " << y << "]" << endl;
    }
};

class GreenCircle : public DrawAPI {
public:
    void drawCircle(int radius, int x, int y) override {
        cout << "Drawing Circle[ color: green, radius: "
         << radius << ", x: " << x << ", " << y << "]" << endl;    
    }
};

//创建Shape抽象基类
class Shape {
protected:
    DrawAPI *draw_api;
    Shape(DrawAPI *draw) : draw_api(draw) {}

public:
    virtual void draw() = 0;
    virtual ~Shape() = default;
};

//创建Shape的实体类
class Circle : public Shape {
private:
    int x, y, radius;

public:
    Circle(int a, int b, int rad, DrawAPI *draw) :
        x(a), y(b), radius(rad), Shape(draw) {}
    void draw() override {
        draw_api->drawCircle(radius, x, y);
    }
};

int main(void) {
    Shape *red_c = new Circle(100, 100, 10, new RedCircle());
    Shape *green_c = new Circle(100, 100, 10, new GreenCircle());

    red_c->draw();
    green_c->draw();

// 输出：
// Drawing Circle[ color: red, radius: 10, x: 100, 100]
// Drawing Circle[ color: green, radius: 10, x: 100, 100]    

    return 0;
}

命令模式：

命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。

先建一个请求类，请求类中有一系列动作。再建立一个命令类继承体系，并通过请求类来初始化命令类对象，即对不同的指令调用对应的请求类动作。最后建立一个调用指令类即指令队列

代码：

//命令模式
#include <iostream>
#include <vector>
using namespace std;

//创建一个请求类
class Stock {
private:
    string name = "abc";
    int quantity = 10;

public:
    void buy() {
        cout << "Stock [ Name: " << name << ", Quantity: " 
            << quantity << " ] bought" << endl;
    }

    void sell() {
        cout << "Stock [ Name: " << name << ", Quantity: " 
            << quantity << " ] sold" << endl;
    }
};

//创建一个命令接口
class Oeder {
public:
    virtual void execute() = 0;
    virtual ~Oeder() = default;
};

//实现Order接口的实体类
class BuyStock : public Oeder {
private:
    Stock abcStock;

public:
    BuyStock(Stock abc) : abcStock(abc) {}
    void execute() override {
        abcStock.buy();
    }
};

class SellStock : public Oeder {
private:
    Stock abcStock;

public:
    SellStock(Stock abc) : abcStock(abc) {}
    void execute() override {
        abcStock.sell();
    }
};

//创建调用指令类
class Broker {
private:
    vector<Oeder*> vec;

public:
    void takeOeder(Oeder *oed) {
        vec.push_back(oed);
    }

    void placeOeder() {
        for(auto indx : vec) {
            indx->execute();
        }
    }
};

int main(void) {
    Stock abcStock;

    BuyStock *buy = new BuyStock(abcStock);
    SellStock *sell = new SellStock(abcStock);

    Broker bk;
    bk.takeOeder(buy);//添加命令
    bk.takeOeder(sell);
    bk.placeOeder();//通知执行命令

    delete buy;
    delete sell;

// 输出：
// Stock [ Name: abc, Quantity: 10 ] bought
// Stock [ Name: abc, Quantity: 10 ] sold

    return 0;
}

责任链模式：

顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推

代码：

//责任链模式
#include <iostream>
#include <vector>
using namespace std;

//请求
class Request {
public:
    unsigned int n;//表示任务等级,10级以下CommnoManager处理,之上则MajorDomo处理
    Request(int x) : n(x) {}
};

//管理者抽象基类
class Manager {
protected:
    Manager *manager;
    string name;

public:
    Manager(string temp) : name(temp) {}
    virtual ~Manager() = default;

    void SetSuccessor(Manager *temp) {
        manager = temp;
    }

    virtual void GetRequest(Request req) = 0;
};

//经理
class CommonManager : public Manager {
public:
    CommonManager(string str) : Manager(str) {}

    void GetRequest(Request req) override {
        if(req.n >= 0 && req.n < 10) {
            cout << "CommonManager: " << name << " " << req.n << endl;
        }else manager->GetRequest(req);//经理无法处理，传递给上一级处理
    }
};

//总监
class MajorDomo : public Manager {
public:
    MajorDomo(string str) : Manager(str) {}
    
    void GetRequest(Request req) override {
        cout << "MajorDomo: " << name << " " << req.n << endl;
    }
};

int main(void) {
    Manager *common = new CommonManager("jingli");
    Manager *major = new MajorDomo("zongjian");

    common->SetSuccessor(major);

    Request cnt1(1), cnt2(11);

    common->GetRequest(cnt1);
    common->GetRequest(cnt2);

// 输出：
// CommonManager: jingli 1
// MajorDomo: zongjian 11

    return 0;
}

中介者模式：

用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

何时使用：多个类相互耦合，形成了网状结构

如何解决：将上述网状结构分离为星型结构

代码：

//中介者模式
#include <iostream>
#include <vector>
using namespace std;

class Colleague;

//中介者抽象基类
class Mediator {
public:
    virtual void Send(string message, Colleague *col) = 0;
    virtual ~Mediator() = default;
};

//同事类的抽象基类
class Colleague {
protected:
    Mediator *med;

public:
    Colleague(Mediator *m) : med(m) {}
    virtual ~Colleague() = default;    

    virtual void Notify(string str) = 0;

    void Send(string str) {
        med->Send(str, this);
    }
};

//同事一
class Colleaguel : public Colleague {
public:
    Colleaguel(Mediator *m) : Colleague(m) {}
    void Notify(string str) override {
        cout << "Colleaguel to Colleague2: " << str << endl;
    }
};

//同事二
class Colleague2 : public Colleague {
public:
    Colleague2(Mediator *m) : Colleague(m) {}
    void Notify(string str) override {
        cout << "Colleague2 to Colleaguel: " << str << endl;
    }
};

//中介者具体类
class ConcreteMediator : public Mediator {
public:
    Colleaguel *col1;
    Colleague2 *col2;
    void Send(string message, Colleague *col) override {
        if(col == col1) col1->Notify(message);
        else col2->Notify(message);
    }
};

int main(void) {
    //中介
    ConcreteMediator *m = new ConcreteMediator();

    //让同事认识中介
    Colleaguel *col1 = new Colleaguel(m);
    Colleague2 *col2 = new Colleague2(m);

    // //让中介认识具体的同事类
    m->col1 = col1;
    m->col2 = col2;

    col1->Send("do you have lunch?");
    col2->Send("no.");

    return 0;
}

享元模式：

享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。享元模式尝试重用现有的同类对象，如果未找到匹配的对象，则创建新对象

代码：

//享元模式
#include <iostream>
#include <vector>
#include <map>
#include <stdlib.h>
using namespace std;

class Shape {
public:
    virtual void draw() = 0;
    virtual void set_x(int) = 0;
    virtual void set_y(int) = 0;
    virtual void set_rad(int) = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape {
private:
    string color;
    int x, y, radius;

public:
    Circle(string col) : color(col) {}
    
    void set_x(int a) override {
        x = a;
    }

    void set_y(int b) override {
        y = b;
    }

    void set_rad(int c) override {
        radius = c;
    }

    void draw() override {
        cout << "Circle: draw() [Color : " << color 
            << ", x : " << x << ", y :" << y << ", radius :" << radius << endl;
    }
};

//创建一个工厂，生成基于给定信息的实体类的对象
class ShapeFactory {
private:
    static map<string, Shape*> mp;

public:
    static Shape* getCircle(string col) {
        Shape *cir = mp[col];
        if(cir == nullptr) {
            cir = new Circle(col);
            mp[col] = cir;
        }
        return cir;
    }    
};

//类静态成员需要在类外声明
map<string, Shape*> ShapeFactory::mp;

int main(void) {
    string col[] = {"Rfj", "zdf", "fes", "zz"};

    for(int i = 0; i < 20; ++i) {
        Shape *cir = ShapeFactory::getCircle(col[rand() % 4]);
        cir->set_x(rand() % 100);
        cir->set_y(rand() % 100);
        cir->set_rad(100);
        cir->draw();
    }

    return 0;
}

解释器模式：

解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等

意图：给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子

主要解决：对于一些固定文法构建一个解释句子的解释器

代码：

// 解释器模式
#include <iostream>
using namespace std;

//创建一个表达式接口
class Expression {
public:
    virtual bool interpret(string context) = 0;
    virtual ~Expression() = default;
};

class TerminalExpression : public Expression {
private:
    string data;

public:
    TerminalExpression(string s) : data(s) {}
    bool interpret(string context) override {
        if(context.find(data) != -1) return true;
        return false;
    }
};

class OrExpression : public Expression {
private:
    Expression *expr1 = nullptr;
    Expression *expr2 = nullptr;

public:
    OrExpression(Expression *exp1, Expression *exp2) :
        expr1(exp1), expr2(exp2) {}

    bool interpret(string context) override {
        return expr1->interpret(context) || expr2->interpret(context);
    }
};

class AndExpression : public Expression {
private:
    Expression *expr1 = nullptr;
    Expression *expr2 = nullptr;

public:
    AndExpression(Expression *exp1, Expression *exp2) :
        expr1(exp1), expr2(exp2) {}

    bool interpret(string context) override {
        return expr1->interpret(context) && expr2->interpret(context);    
    }
};

Expression* getMaleExpression() {
    //规则：Robert 和 John 是男性
    Expression *robert = new TerminalExpression("robert");
    Expression *john = new TerminalExpression("john");
    return new OrExpression(robert, john);
}

Expression* getMarriedWomanExpression() {
    // 规则：Julie 是一个已婚女性
    Expression *julie = new TerminalExpression("julie");
    Expression *married = new TerminalExpression("married");
    return new AndExpression(julie, married);
}

int main(void) {
    Expression *isMale = getMaleExpression();
    Expression *isMarrieWoman = getMarriedWomanExpression();

    cout << "john is male? " << isMale->interpret("john") << endl;
    cout << "julie is a married women? " << isMarrieWoman->interpret("married julie") << endl;

// 输出：
// john is male? 1
// julie is a married women? 1

    delete isMale;
    delete isMarrieWoman;

    return 0;
}