(设计模式) (李建忠 C++) 23种设计模式

组件协作

模板方法

父类中定义组件（函数）的调用流程，每个组件使用虚函数进行实现，然后子类中可以重写父类中虚函数的实现。
如果我们发现一个算法的组件（函数）的调用流程都是一样的，但是步骤中的各个组件的实现可能有所差异，此时会使用模板方法。
【注】稳定的是骨架，变化的是组件的具体实现。

版本1

//程序库开发人员
class Library {
public:
    void Step1() {
        //...
    }

    void Step3() {
        //...
    }

    void Step5() {
        //...
    }
};


//应用程序开发人员
class Application {
public:
    bool Step2() {
        //...
    }

    void Step4() {
        //...
    }
};

// 用户使用算法
int main() {
    Library lib();
    Application app();

    lib.Step1();

    if (app.Step2()) {
        lib.Step3();
    }

    for (int i = 0; i < 4; i++) {
        app.Step4();
    }

    lib.Step5();
}

要调用这个算法，用户需要调用step1~step5，这个过程可以由框架本身实现，而不是用户去实现，改进代码如下：

//程序库开发人员
class Library {
public:
    //稳定 template method
    void Run() {
        Step1();

        if (Step2()) {  //支持变化 ==> 虚函数的多态调用
            Step3();
        }

        for (int i = 0; i < 4; i++) {
            Step4();  //支持变化 ==> 虚函数的多态调用
        }

        Step5();
    }
    virtual ~Library() {
    }

protected:
    void Step1() {  //稳定
        //.....
    }
    void Step3() {  //稳定
        //.....
    }
    void Step5() {  //稳定
        //.....
    }

    virtual bool Step2() = 0;  //变化
    virtual void Step4() = 0;  //变化
};

//应用程序开发人员
class Application : public Library {
protected:
    virtual bool Step2() {
        //... 子类重写实现
    }

    virtual void Step4() {
        //... 子类重写实现
    }
};

int main() {
    Library* pLib = new Application();
    lib->Run();

    delete pLib;
}

上面将具体的实现子类实现，在muduo库中也有类似的方法，不过muduo库中使用的回调函数（函数指针）实现的。
子类可以重写的虚函数，一般设置为protected，因为这些方法一般不需要对用户可见。

策略模式

使用了抽象类，子类中使用定义具体的抽象类实现。当类A使用中使用抽象类指针时，A类中一般会定义一个函数给抽象类指针传递具体的对象，那么类A就可以中就可以根据指针指向的对象实现多态。
【注】类A是稳定的，变化的是子类。

模板方法中父类定义了处理流程，子类定义了组件的具体实现。
策略模式：我觉得主要讲的是将算法抽象成一个抽象类，不同的算法都实现这个抽象类。

当if else或switch的可能性在未来可能会继续扩展时，就要想到用策略模式。策略模式中抽象类指针接收不同的子类对象来实现if else或switch。

版本1：

enum TaxBase {
    CN_Tax,
    US_Tax,
    DE_Tax,
    FR_Tax  //更改
};

class SalesOrder {
    TaxBase tax;

public:
    double CalculateTax() {
        //...

        if (tax == CN_Tax) {
            // CN***********
        } else if (tax == US_Tax) {
            // US***********
        } else if (tax == DE_Tax) {
            // DE***********
        } else if (tax == FR_Tax) {  //更改
                                     //...
        }

        //....
    }
};

class TaxStrategy {
public:
    virtual double Calculate(const Context& context) = 0;
    virtual ~TaxStrategy() {
    }
};

class CNTax : public TaxStrategy {
public:
    virtual double Calculate(const Context& context) {
        //***********
    }
};

class USTax : public TaxStrategy {
public:
    virtual double Calculate(const Context& context) {
        //***********
    }
};

class DETax : public TaxStrategy {
public:
    virtual double Calculate(const Context& context) {
        //***********
    }
};

//扩展
//*********************************
class FRTax : public TaxStrategy {
public:
    virtual double Calculate(const Context& context) {
        //.........
    }
};

class SalesOrder {
private:
    TaxStrategy* strategy;

public:
    SalesOrder(StrategyFactory* strategyFactory) {
        this->strategy = strategyFactory->NewStrategy();
    }
    ~SalesOrder() {
        delete this->strategy;
    }

public
    double CalculateTax() {
        //...
        Context context();

        double val = strategy->Calculate(context);  //多态调用
        //...
    }
};

对象创建

工厂方法

抽象工厂

对象性能

单件模式 Singleton

单件模式：保证在系统中只存在一个实例。