标签：... 23 int void virtual public 设计模式 class

https://www.bilibili.com/video/BV1Yr4y157Ci?p=26&spm_id_from=pageDriver&vd_source=26936cf2df4b6c321f63de2ec139cfdc

八大原则

依赖倒置原则（DIP）
•高层模块(稳定)不应该依赖于低层模块(变化)，二者都应该依赖
于抽象(稳定) 。
•抽象(稳定)不应该依赖于实现细节(变化) ，实现细节应该依赖于
抽象(稳定)。

开放封闭原则（OCP）
•对扩展开放，对更改封闭。
•类模块应该是可扩展的，但是不可修改

单一职责原则（SRP）
•一个类应该仅有一个引起它变化的原因。
•变化的方向隐含着类的责任。

Liskov 替换原则（LSP）
•子类必须能够替换它们的基类(IS-A)。
•继承表达类型抽象。

接口隔离原则（ISP）
•不应该强迫客户程序依赖它们不用的方法。
•接口应该小而完备。

优先使用对象组合，而不是类继承
•类继承通常为“白箱复用”，对象组合通常为“黑箱复用”。
•继承在某种程度上破坏了封装性，子类父类耦合度高。
•而对象组合则只要求被组合的对象具有良好定义的接口，耦合
度低。

封装变化点
•使用封装来创建对象之间的分界层，让设计者可以在分界层的
一侧进行修改，而不会对另一侧产生不良的影响，从而实现层
次间的松耦合。

针对接口编程，而不是针对实现编程
•不将变量类型声明为某个特定的具体类，而是声明为某个接口。
•客户程序无需获知对象的具体类型，只需要知道对象所具有的
接口。
•减少系统中各部分的依赖关系，从而实现“高内聚、松耦合”
的类型设计方案。

设计模式分类

组件协作：
• Template Method
• Observer / Event
• Strategy

单一职责：
• Decorator
• Bridge

对象创建:
• Factory Method
• Abstract Factory
• Prototype
• Builder

对象性能：
• Singleton
• Flyweight

接口隔离:
• Façade
• Proxy
• Mediator
• Adapter

状态变化：
• Memento
• State

数据结构：
• Composite
• Iterator
• Chain of Resposibility

行为变化：
• Command
• Visitor

领域问题： • Interpreter

”组件协作”模式——晚绑定

现代软件专业分工之后的第一个结果是“框架与应用程序的划
分”，“组件协作”模式通过晚期绑定，来实现框架与应用程序之
间的松耦合，是二者之间协作时常用的模式

1 Template Method 模板模式

定义一个操作中的算法的骨架 (稳定)，而将一些步骤延迟 (变化)到子类中。Template Method使得子类可以不改变 (复用)一个算法的结构即可重定义(override 重写)该算法的某些特定步骤。

修改前：

//应用程序开发人员
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();
}

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

修改后：

//应用程序开发人员

class Application : public Library {

protected:

    virtual bool Step2(){

        //... 子类重写实现

    }

  

    virtual void Step4() {

        //... 子类重写实现
    }
};

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

//程序库开发人员
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; //变化
};

2 Strategy 策略模式

定义一系列算法，把它们一个个封装起来，并且使它们可互相替换（变化）。该模式使得算法可独立于使用它的客户程序(稳定)而变化（扩展，子类化）。

Strategy及其子类为组件提供了一系列可重用的算法，从而可以使得类型在运行时方便地根据需要在各个算法之间进行切换。
Strategy模式提供了用条件判断语句以外的另一种选择，消除条件判断语句，就是在解耦合。含有许多条件判断语句的代码通常都需要Strategy模式。
如果Strategy对象没有实例变量，那么各个上下文可以共享同一个Strategy对象，从而节省对象开销。

修改前：

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); //多态调用
        //...
    }
};

3 Observer/Event 观察者模式

定义对象间的一种一对多（变化）的依赖关系，以便当一个对象(Subject)的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。 ——《设计模式》GoF

修改前：

class FileSplitter
{
    string m_filePath;
    int m_fileNumber;
    ProgressBar* m_progressBar;

public:
    FileSplitter(const string& filePath, int fileNumber, ProgressBar* progressBar) :
        m_filePath(filePath),
        m_fileNumber(fileNumber),
        m_progressBar(progressBar){
    }

    void split(){
        //1.读取大文件
        //2.分批次向小文件中写入
        for (int i = 0; i < m_fileNumber; i++){
            //...
            float progressValue = m_fileNumber;
            progressValue = (i + 1) / progressValue;
            m_progressBar->setValue(progressValue);
        }
    }
};

class IProgress{
public:
    virtual void DoProgress(float value)=0;
    virtual ~IProgress(){}
};

class FileSplitter
{
    string m_filePath;
    int m_fileNumber;
    List<IProgress*>  m_iprogressList; // 抽象通知机制，支持多个观察者
public:
    FileSplitter(const string& filePath, int fileNumber) :
        m_filePath(filePath),
        m_fileNumber(fileNumber){
    }
    void split(){
        //1.读取大文件
        //2.分批次向小文件中写入
        for (int i = 0; i < m_fileNumber; i++){
            //...
            float progressValue = m_fileNumber;
            progressValue = (i + 1) / progressValue;
            onProgress(progressValue);//发送通知
        }
    }

    void addIProgress(IProgress* iprogress){
        m_iprogressList.push_back(iprogress);
    }
    
    void removeIProgress(IProgress* iprogress){
        m_iprogressList.remove(iprogress);
    }

protected:
    virtual void onProgress(float value){
        List<IProgress*>::iterator itor=m_iprogressList.begin();
        while (itor != m_iprogressList.end() )
            (*itor)->DoProgress(value); //更新进度条
            itor++;
        }
    }
};

after：

class MainForm : public Form
{
    TextBox* txtFilePath;
    TextBox* txtFileNumber;
    ProgressBar* progressBar;
public:
    void Button1_Click(){
        string filePath = txtFilePath->getText();
        int number = atoi(txtFileNumber->getText().c_str());
        FileSplitter splitter(filePath, number, progressBar);
        splitter.split();
    }
};

class MainForm : public Form, public IProgress
{
    TextBox* txtFilePath;
    TextBox* txtFileNumber;
    ProgressBar* progressBar;
public:
    void Button1_Click(){
        string filePath = txtFilePath->getText();
        int number = atoi(txtFileNumber->getText().c_str());
        ConsoleNotifier cn;
        FileSplitter splitter(filePath, number);
        splitter.addIProgress(this); //订阅通知
        splitter.addIProgress(&cn)； //订阅通知
        splitter.split();
        splitter.removeIProgress(this);
    }
    virtual void DoProgress(float value){
        progressBar->setValue(value);
    }
};

class ConsoleNotifier : public IProgress {
public:
    virtual void DoProgress(float value){
        cout << ".";
    }
};

单一职责模式——划清责任

在软件组件的设计中，如果责任划分的不清晰，使用继承得到的
结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，
这时候的关键是划清责任。

4 Decorator 装饰模式

//业务操作
class Stream{
public：
    virtual char Read(int number)=0;
    virtual void Seek(int position)=0;
    virtual void Write(char data)=0;
    virtual ~Stream(){}
};

//主体类
class FileStream: public Stream{
public:
    virtual char Read(int number){
        //读文件流
    }
    virtual void Seek(int position){
        //定位文件流
    }
    virtual void Write(char data){
        //写文件流
    }
};

class NetworkStream :public Stream{
public:
    virtual char Read(int number){
        //读网络流
    }
    virtual void Seek(int position){
        //定位网络流
    }
    virtual void Write(char data){
        //写网络流
    }
};

class MemoryStream :public Stream{
public:
    virtual char Read(int number){
        //读内存流
    }
    virtual void Seek(int position){
        //定位内存流
    }
    virtual void Write(char data){
        //写内存流
    }
};

//扩展操作
class CryptoFileStream :public FileStream{
public:
    virtual char Read(int number){
        //额外的加密操作...
        FileStream::Read(number);//读文件流
    }
    virtual void Seek(int position){
        //额外的加密操作...
        FileStream::Seek(position);//定位文件流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        FileStream::Write(data);//写文件流
        //额外的加密操作...
    }
};

class CryptoNetworkStream : :public NetworkStream{
public:
    virtual char Read(int number){
        //额外的加密操作...
        NetworkStream::Read(number);//读网络流
    }
    virtual void Seek(int position){
        //额外的加密操作...
        NetworkStream::Seek(position);//定位网络流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        NetworkStream::Write(data);//写网络流
        //额外的加密操作...
    }
};

class CryptoMemoryStream : public MemoryStream{
public:
    virtual char Read(int number){
        //额外的加密操作...
        MemoryStream::Read(number);//读内存流
    }
    virtual void Seek(int position){
        //额外的加密操作...
        MemoryStream::Seek(position);//定位内存流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        MemoryStream::Write(data);//写内存流
        //额外的加密操作...
    }
};

class BufferedFileStream : public FileStream{
    //...
};

class BufferedNetworkStream : public NetworkStream{
    //...
};

class BufferedMemoryStream : public MemoryStream{
    //...
} 

class CryptoBufferedFileStream :public FileStream{
public:
    virtual char Read(int number){
        //额外的加密操作...
        //额外的缓冲操作...
        FileStream::Read(number);//读文件流
    }
    virtual void Seek(int position){
        //额外的加密操作...
        //额外的缓冲操作...
        FileStream::Seek(position);//定位文件流
        //额外的加密操作...
        //额外的缓冲操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        //额外的缓冲操作...
        FileStream::Write(data);//写文件流
        //额外的加密操作...
        //额外的缓冲操作...
    }
};

void Process(){
        //编译时装配
    CryptoFileStream *fs1 = new CryptoFileStream();
    BufferedFileStream *fs2 = new BufferedFileStream();
    CryptoBufferedFileStream *fs3 =new CryptoBufferedFileStream();
}

version2:

//业务操作

class Stream{
public：
    virtual char Read(int number)=0;
    virtual void Seek(int position)=0;
    virtual void Write(char data)=0;
    virtual ~Stream(){}
};
//主体类
class FileStream: public Stream{
public:
    virtual char Read(int number){
        //读文件流
    }
    virtual void Seek(int position){
        //定位文件流
    }
    virtual void Write(char data){
        //写文件流
    }
};
  
class NetworkStream :public Stream{
public:
    virtual char Read(int number){
        //读网络流
    }
    virtual void Seek(int position){
        //定位网络流
    }
    virtual void Write(char data){
        //写网络流
    }
};
  
class MemoryStream :public Stream{
public:
    virtual char Read(int number){
        //读内存流
    }
    virtual void Seek(int position){
        //定位内存流
    }
    virtual void Write(char data){
        //写内存流
    }
};
  
//扩展操作
  
class CryptoStream: public Stream {
    Stream* stream;//...
  
public:
    CryptoStream(Stream* stm):stream(stm){
    }
    virtual char Read(int number){
        //额外的加密操作...
        stream->Read(number);//读文件流
    }
    virtual void Seek(int position){
        //额外的加密操作...
        stream::Seek(position);//定位文件流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        stream::Write(data);//写文件流
        //额外的加密操作...
    }
};  

class BufferedStream : public Stream{
    Stream* stream;//...
public:
    BufferedStream(Stream* stm):stream(stm){
    }
    //...
};
  
void Process(){
    //运行时装配
    FileStream* s1=new FileStream();
    CryptoStream* s2=new CryptoStream(s1);
    BufferedStream* s3=new BufferedStream(s1);
    BufferedStream* s4=new BufferedStream(s2);
  
}

version3:

//业务操作

class Stream{
public：
    virtual char Read(int number)=0;
    virtual void Seek(int position)=0;
    virtual void Write(char data)=0;
    virtual ~Stream(){}
};

//主体类
class FileStream: public Stream{

public:

    virtual char Read(int number){

        //读文件流

    }

    virtual void Seek(int position){

        //定位文件流

    }

    virtual void Write(char data){

        //写文件流

    }

  

};

  

class NetworkStream :public Stream{

public:

    virtual char Read(int number){

        //读网络流

    }

    virtual void Seek(int position){

        //定位网络流

    }

    virtual void Write(char data){

        //写网络流

    }

};

  

class MemoryStream :public Stream{

public:

    virtual char Read(int number){

        //读内存流

    }

    virtual void Seek(int position){

        //定位内存流

    }

    virtual void Write(char data){

        //写内存流

    }

};

  

//扩展操作

  

DecoratorStream: public Stream{

protected:

    Stream* stream;//...

    DecoratorStream(Stream * stm):stream(stm){

    }

};

  

class CryptoStream: public DecoratorStream {

  

public:

    CryptoStream(Stream* stm):DecoratorStream(stm){

    }

    virtual char Read(int number){

        //额外的加密操作...

        stream->Read(number);//读文件流

    }

    virtual void Seek(int position){

        //额外的加密操作...

        stream::Seek(position);//定位文件流

        //额外的加密操作...

    }

    virtual void Write(byte data){

        //额外的加密操作...

        stream::Write(data);//写文件流

        //额外的加密操作...

    }

};

  
  
  

class BufferedStream : public DecoratorStream{

    Stream* stream;//...

public:

    BufferedStream(Stream* stm):DecoratorStream(stm){

    }

    //...

};

  
  
  
  

void Process(){

  

    //运行时装配

    FileStream* s1=new FileStream();

    CryptoStream* s2=new CryptoStream(s1);

    BufferedStream* s3=new BufferedStream(s1);

    BufferedStream* s4=new BufferedStream(s2);

  

}

5 Bridge 桥模式

将抽象部分(业务功能)与实现部分(平台实现)分离，使它们
都可以独立地变化。

动机
由于某些类型的固有的实现逻辑，使得它们具有两个变化的维度，
乃至多个纬度的变化。
如何应对这种“多维度的变化”？如何利用面向对象技术来使得
类型可以轻松地沿着两个乃至多个方向变化，而不引入额外的复杂
度？

总结
Bridge模式使用“对象间的组合关系”解耦了抽象和实现之间固有的绑定关系，使得抽象和实现可以沿着各自的维度来变化。所谓抽象和实现沿着各自纬度的变化，即“子类化”它们。
Bridge模式有时候类似于多继承方案，但是多继承方案往往违背单一职责原则（即一个类只有一个变化的原因），复用性比较差。Bridge模式是比多继承方案更好的解决方法。
Bridge模式的应用一般在“两个非常强的变化维度”，有时一个类也有多于两个的变化维度，这时可以使用Bridge的扩展模式。

before:

class Messager{

public:

    virtual void Login(string username, string password)=0;

    virtual void SendMessage(string message)=0;

    virtual void SendPicture(Image image)=0;

  

    virtual void PlaySound()=0;

    virtual void DrawShape()=0;

    virtual void WriteText()=0;

    virtual void Connect()=0;

    virtual ~Messager(){}

};

  
  

//平台实现

  

class PCMessagerBase : public Messager{

public:

    virtual void PlaySound(){

        //**********

    }

    virtual void DrawShape(){

        //**********

    }

    virtual void WriteText(){

        //**********

    }

    virtual void Connect(){

        //**********

    }

};

  

class MobileMessagerBase : public Messager{

public:

    virtual void PlaySound(){

        //==========

    }

    virtual void DrawShape(){

        //==========

    }

    virtual void WriteText(){

        //==========

    }

    virtual void Connect(){

        //==========

    }

};

  
  
  

//业务抽象

  

class PCMessagerLite : public PCMessagerBase {

public:

    virtual void Login(string username, string password){

        PCMessagerBase::Connect();

        //........

    }

    virtual void SendMessage(string message){

        PCMessagerBase::WriteText();

        //........

    }

    virtual void SendPicture(Image image){

        PCMessagerBase::DrawShape();

        //........

    }

};

  
  
  

class PCMessagerPerfect : public PCMessagerBase {

public:

    virtual void Login(string username, string password){

        PCMessagerBase::PlaySound();

        //********

        PCMessagerBase::Connect();

        //........

    }

    virtual void SendMessage(string message){

        PCMessagerBase::PlaySound();

        //********

        PCMessagerBase::WriteText();

        //........

    }

    virtual void SendPicture(Image image){

        PCMessagerBase::PlaySound();

        //********

        PCMessagerBase::DrawShape();

        //........

    }

};

  
  

class MobileMessagerLite : public MobileMessagerBase {

public:

    virtual void Login(string username, string password){

        MobileMessagerBase::Connect();

        //........

    }

    virtual void SendMessage(string message){

        MobileMessagerBase::WriteText();

        //........

    }

    virtual void SendPicture(Image image){

        MobileMessagerBase::DrawShape();

        //........

    }

};

  
  

class MobileMessagerPerfect : public MobileMessagerBase {

public:

    virtual void Login(string username, string password){

        MobileMessagerBase::PlaySound();

        //********

        MobileMessagerBase::Connect();

        //........

    }

    virtual void SendMessage(string message){

        MobileMessagerBase::PlaySound();

        //********

        MobileMessagerBase::WriteText();

        //........

    }

    virtual void SendPicture(Image image){

        MobileMessagerBase::PlaySound();

        //********

        MobileMessagerBase::DrawShape();

        //........

    }

};

  
  

void Process(){

        //编译时装配

        Messager *m =

            new MobileMessagerPerfect();

}

after:

class Messager{

protected:

     MessagerImp* messagerImp;//...

public:

    virtual void Login(string username, string password)=0;

    virtual void SendMessage(string message)=0;

    virtual void SendPicture(Image image)=0;

    virtual ~Messager(){}

};

  

class MessagerImp{

public:

    virtual void PlaySound()=0;

    virtual void DrawShape()=0;

    virtual void WriteText()=0;

    virtual void Connect()=0;

    virtual MessagerImp(){}

};

  
  

//平台实现 n

class PCMessagerImp : public MessagerImp{

public:

    virtual void PlaySound(){

        //**********

    }

    virtual void DrawShape(){

        //**********

    }

    virtual void WriteText(){

        //**********

    }

    virtual void Connect(){

        //**********

    }

};

  

class MobileMessagerImp : public MessagerImp{

public:

    virtual void PlaySound(){

        //==========

    }

    virtual void DrawShape(){

        //==========

    }

    virtual void WriteText(){

        //==========

    }

    virtual void Connect(){

        //==========

    }

};

  
  
  

//业务抽象 m

  

//类的数目：1+n+m

  

class MessagerLite :public Messager {

  

public:

    virtual void Login(string username, string password){

        messagerImp->Connect();

        //........

    }

    virtual void SendMessage(string message){

        messagerImp->WriteText();

        //........

    }

    virtual void SendPicture(Image image){

        messagerImp->DrawShape();

        //........

    }

};

class MessagerPerfect  :public Messager {
public:
    virtual void Login(string username, string password){
        messagerImp->PlaySound();
        //********
        messagerImp->Connect();
        //........
    }
    virtual void SendMessage(string message){
        messagerImp->PlaySound();
        //********
        messagerImp->WriteText();
        //........
    }
    virtual void SendPicture(Image image){
        messagerImp->PlaySound();
        //********
        messagerImp->DrawShape();
        //........
    }
};
void Process(){
    //运行时装配
    MessagerImp* mImp=new PCMessagerImp();
    Messager *m =new Messager(mImp);
}

"对象创建”模式

通过“对象创建” 模式绕开new，来避免对象创建（new）过程
中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它
是接口抽象之后的第一步工作。

典型模式

Factory Method
Abstract Factory
Prototype
Builder

6 Factory Method 工厂模式

定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟（目的：解耦，手段：虚函数）到子类。 ——《设计模式》GoF

在软件系统中，经常面临着创建对象的工作；由于需求的变化，需要创建的对象的具体类型经常变化。如何绕过常规的对象创建方法（new），提供一种“封装机制，来避免客户程序和这猴子那个”具体对象创建工作“的紧耦合。

为了应对未来的变化，一个对象的类型往往应该声明为抽象类或者接口，而不是一个具体的类。

//mainform.cpp
class MainForm : public Form
{
    TextBox* txtFilePath;
    TextBox* txtFileNumber;
    ProgressBar* progressBar;
public:
    void Button1_Click(){
        ISplitter * splitter=
            new BinarySplitter();//依赖具体类
        splitter->split();
    }
};

//FileSplitter.cpp
class ISplitter{
public:
    virtual void split()=0;
    virtual ~ISplitter(){}
};
class BinarySplitter : public ISplitter{
};

class TxtSplitter: public ISplitter{
};

class PictureSplitter: public ISplitter{
};

class VideoSplitter: public ISplitter{
};

修改后：

//MainForm.cpp
class MainForm : public Form
{
    SplitterFactory*  factory;//工厂
public:
    MainForm(SplitterFactory*  factory){
        this->factory=factory;
    }
    void Button1_Click(){
        ISplitter * splitter=
            factory->CreateSplitter(); //多态new
        splitter->split();
    }
};

//ISPlitterFactory.cpp
//抽象类
class ISplitter{
public:
    virtual void split()=0;
    virtual ~ISplitter(){}
};

//工厂基类
class SplitterFactory{
public:
    virtual ISplitter* CreateSplitter()=0;
    virtual ~SplitterFactory(){}
};

//FileSplitter.cpp
//具体类
class BinarySplitter : public ISplitter{
};

class TxtSplitter: public ISplitter{
};

class PictureSplitter: public ISplitter{
};

class VideoSplitter: public ISplitter{
};
//具体工厂
class BinarySplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new BinarySplitter();
    }
};
class TxtSplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new TxtSplitter();
    }
};

class PictureSplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new PictureSplitter();
    }
};

class VideoSplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new VideoSplitter();
    }
};

7 Abstract Factory 抽象工厂

提供一个接口，让该接口负责创建一系列“相关或者相互依
赖的对象”，无需指定它们具体的类。

version 1：

class EmployeeDAO{
public:
    vector<EmployeeDO> GetEmployees(){
        SqlConnection* connection = new SqlConnection();
        connection->ConnectionString = "...";
        SqlCommand* command = new SqlCommand();
        command->CommandText="...";
        command->SetConnection(connection);
        SqlDataReader* reader = command->ExecuteReader();
        while (reader->Read()){
        }
    }
};

由于在类里面 new 一个实例是很烂的做法，所以按照前面一章Factory Method的方法，在外面创建工厂类，通过工厂类返回对象的方法进行解耦——三个工厂创建三个对象。
得到下面的代码

//数据库访问有关的基类
class IDBConnection{
};
class IDBConnectionFactory{
public:
    virtual IDBConnection* CreateDBConnection()=0;
};

class IDBCommand{
};
class IDBCommandFactory{
public:
    virtual IDBCommand* CreateDBCommand()=0;
};

class IDataReader{
};
class IDataReaderFactory{
public:
    virtual IDataReader* CreateDataReader()=0;
};

//支持SQL Server
class SqlConnection: public IDBConnection{
};
class SqlConnectionFactory:public IDBConnectionFactory{
};

class SqlCommand: public IDBCommand{
};
class SqlCommandFactory:public IDBCommandFactory{
};

class SqlDataReader: public IDataReader{
};
class SqlDataReaderFactory:public IDataReaderFactory{
};

//支持Oracle
class OracleConnection: public IDBConnection{
};
class OracleCommand: public IDBCommand{
};
class OracleDataReader: public IDataReader{
};

class EmployeeDAO{
    IDBConnectionFactory* dbConnectionFactory;
    IDBCommandFactory* dbCommandFactory;
    IDataReaderFactory* dataReaderFactory;

public:
    vector<EmployeeDO> GetEmployees(){
        IDBConnection* connection =
            dbConnectionFactory->CreateDBConnection();
        connection->ConnectionString("...");

        IDBCommand* command =
            dbCommandFactory->CreateDBCommand();
        command->CommandText("...");
        command->SetConnection(connection); //关联性
        IDBDataReader* reader = command->ExecuteReader(); //关联性
        while (reader->Read()){
        }
    }
};

观察到上面的代码中 command->SetConnectoin(connection)其实要求传进来的工厂子类必须要是同组的——在未来调用的时候会有问题，如果三个不一致怎么办？
为了解决三个工厂不一致的问题，将三个工厂合成一个类，保证其关联性。
（如果不需要创建三个工厂，那就跟上一章的工厂模式是一样的）

在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建工作。
如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？

//数据库访问有关的基类
class IDBConnection{
};
class IDBCommand{
};
class IDataReader{
};

class IDBFactory{
public:
    virtual IDBConnection* CreateDBConnection()=0;
    virtual IDBCommand* CreateDBCommand()=0;
    virtual IDataReader* CreateDataReader()=0;
};
//支持SQL Server
class SqlConnection: public IDBConnection{
};
class SqlCommand: public IDBCommand{
};
class SqlDataReader: public IDataReader{
};

class SqlDBFactory:public IDBFactory{
public:
    virtual IDBConnection* CreateDBConnection()=0;
    virtual IDBCommand* CreateDBCommand()=0;
    virtual IDataReader* CreateDataReader()=0;
};

//支持Oracle
class OracleConnection: public IDBConnection{
};
class OracleCommand: public IDBCommand{
};
class OracleDataReader: public IDataReader{
};

class EmployeeDAO{
    IDBFactory* dbFactory;
public:
    vector<EmployeeDO> GetEmployees(){
        IDBConnection* connection = dbFactory->CreateDBConnection();
        connection->ConnectionString("...");
        IDBCommand* command = dbFactory->CreateDBCommand();
        command->CommandText("...");
        command->SetConnection(connection); //关联性
        IDBDataReader* reader = command->ExecuteReader(); //关联性
        while (reader->Read()){
          }
    }
};

8 Prototype 原型模式

使用原型实例指定创建对象的种类，然后通过拷贝（深拷贝）这些原型来创建新的对象。——《设计模式》GoF

当对象比较复杂，且刚初始化的对象的状态不够好的时候，就可以在这里采用clone的方法，克隆出一个状态比较好实现的对象。

在软件系统中，经常面临着”某些结构复杂的对象“的创建工作；由于需求的变化，这些对象经常面临着剧烈的变化，但是它们却拥有比较稳定一致的接口。
如何应对这种变化？如何向“客户程序（使用这些对象的程序）“隔离出”这些易变对象“，从而使得”以来这些易变对象的客户程序“不随着需求改变而改变？

//Prototype.cpp
//抽象类
class ISplitter{
public:
    virtual void split()=0;
    virtual ISplitter* clone()=0; //通过克隆自己来创建对象
    virtual ~ISplitter(){}
};

//ConcretePrototype.cpp
//具体类
class BinarySplitter : public ISplitter{
public:
   virtual ISplitter* clone(){
        return new BinarySplitter(*this);
    }
};

class TxtSplitter: public ISplitter{
public:
    virtual ISplitter* clone(){
        return new TxtSplitter(*this);
    }
};

class PictureSplitter: public ISplitter{
public:
    virtual ISplitter* clone(){
        return new PictureSplitter(*this);
    }
};

class VideoSplitter: public ISplitter{
public:
    virtual ISplitter* clone(){
        return new VideoSplitter(*this);
    }
};

class MainForm : public Form
{
    ISplitter*  prototype;//原型对象
public:
    MainForm(ISplitter*  prototype){
        this->prototype=prototype;
    }
    void Button1_Click(){
        ISplitter * splitter=
            prototype->clone(); //克隆原型
        splitter->split();
    }
};

、

9 Builder 构建器

将一个复杂对象的构建与其表示相分离，使得同样的构建过程(稳定)可以创建不同的表示(变化)。
——《设计模式》GoF

动机
在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
如何应对这种变化？如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定构建算法”不随着需求改变而改变？

要点总结
Builder 模式主要用于“分步骤构建一个复杂的对象”。在这其中 “分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。
变化点在哪里，封装哪里—— Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。
在Builder模式中，要注意不同语言中构造器内调用虚函数的差别（C++ vs. C#) 。


class House{
    //....
};

class HouseBuilder {
public:
    House* GetResult(){
        return pHouse;
    }
    virtual ~HouseBuilder(){}
protected:
    House* pHouse;
    virtual void BuildPart1()=0;
    virtual void BuildPart2()=0;
    virtual void BuildPart3()=0;
    virtual void BuildPart4()=0;
    virtual void BuildPart5()=0;
};

class StoneHouse: public House{
};

class StoneHouseBuilder: public HouseBuilder{
protected:
    virtual void BuildPart1(){
        //pHouse->Part1 = ...;
    }
    virtual void BuildPart2(){
    }
    virtual void BuildPart3(){
    }
    virtual void BuildPart4(){
    }
    virtual void BuildPart5(){
    }
};

class HouseDirector{
public:
    HouseBuilder* pHouseBuilder;
    HouseDirector(HouseBuilder* pHouseBuilder){
        this->pHouseBuilder=pHouseBuilder;
    }
    House* Construct(){
        pHouseBuilder->BuildPart1();
        for (int i = 0; i < 4; i++){
            pHouseBuilder->BuildPart2();
        }
        bool flag=pHouseBuilder->BuildPart3();
        if(flag){
            pHouseBuilder->BuildPart4();
        }
        pHouseBuilder->BuildPart5();
        return pHouseBuilder->GetResult();
    }
};

红色为抽象的固定的部分

”对象性能“模式

面向对象很好地解决了”抽象“的问题。但是必不可免地要付出一定的代价。对于哦通常情况来讲，面向对象地成本大都可以忽略不计。但是某些情况，面向对象所带来的成本必须谨慎处理。

11 Singleton

class Singleton{
private:
    Singleton();
    Singleton(const Singleton& other);
public:
    static Singleton* getInstance();
    static Singleton* m_instance;
};

Singleton* Singleton::m_instance=nullptr;

//线程非安全版本
Singleton* Singleton::getInstance() {
    if (m_instance == nullptr) {
        m_instance = new Singleton();
    }
    return m_instance;
}

//线程安全版本，但锁的代价过高
Singleton* Singleton::getInstance() {
    Lock lock;
    if (m_instance == nullptr) {
        m_instance = new Singleton();
    }
    return m_instance;
}  
 

//双检查锁，但由于内存读写reorder不安全
//通常对于m_instance= new Signleton()的理解是 1. 开辟内存 2. 调用构造器 3.给内存赋值。但是在一些机器上面会执行1，3，2的顺序——reorder。
//对于多线程应用来说，如果一个线程执行了1，3步，还没执行第2步，m_instance这时候已经不是nullptr,但是由于还没有执行构造器，所以另外一个线程会直接获取到一个错误的m_instance。
Singleton* Singleton::getInstance() {
    if(m_instance==nullptr){
        Lock lock;//锁后检查，避免每次读取操作都要检查锁
        if (m_instance == nullptr) {
            m_instance = new Singleton();
        }
    }
    return m_instance;
}

//C++ 11版本之后的跨平台实现 (volatile)
std::atomic<Singleton*> Singleton::m_instance;
std::mutex Singleton::m_mutex;

Singleton* Singleton::getInstance() {
    Singleton* tmp = m_instance.load(std::memory_order_relaxed);
    std::atomic_thread_fence(std::memory_order_acquire);//获取内存fence
    if (tmp == nullptr) {
        std::lock_guard<std::mutex> lock(m_mutex);
        tmp = m_instance.load(std::memory_order_relaxed);
        if (tmp == nullptr) {
            tmp = new Singleton;
            std::atomic_thread_fence(std::memory_order_release);//释放内存fence
            m_instance.store(tmp, std::memory_order_relaxed);
        }
    }
    return tmp;
}

Singleton模式中的实例构造器可以设置为protected 以允许子类派生。

12 Flyweight 享元模式

运行共享技术有效的支持大量细粒度的对象。——《设计模式》GoF

动机：
在软件兄系统采用纯粹对象方案的问题在于大量细粒度的对象会很快充斥在系统中，从而带来很高的运行时代价——主要指内存需求方面的代价。
如果在避免大量细粒度对象问题的同时，让外部客户程序仍然能够透明的使用面向的方式来进行操作。

实现一个对象池，管理大量重复创建的对象。
（这里一般要实现只读的方式）

class Font {
private:
    //unique object key
    string key;
    //object state
    //....
public:
    Font(const string& key){
        //...
    }
};

class FontFactory{
private:
    map<string,Font* > fontPool;
public:
    Font* GetFont(const string& key){
        map<string,Font*>::iterator item=fontPool.find(key);
        if(item!=footPool.end()){
            return fontPool[key];
        }
        else{
            Font* font = new Font(key);
            fontPool[key]= font;
            return font;
        }
    }
    void clear(){
        //...
    }
};

接口隔离

在组件构建过程中，某些接口之间直接的依赖常常会带来很多问题、甚至根本无法实现。采用添加一层间接（稳定）接口，来隔离本来互相紧密关联的接口是一种常见的解决方案。

13 Facade 门面模式

为子系统中的一组接口提供一个一致（稳定）的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用（复用）。——《设计模式》GoF

14 Proxy 代理模式

为其他对象提供一种代理以控制（隔离，使用接口）对这个对象的访问。

class ISubject{
public:
    virtual void process();
};


class RealSubject: public ISubject{
public:
    virtual void process(){
        //....
    }
};

class ClientApp{
    
    ISubject* subject;
    
public:
    
    ClientApp(){
        subject=new RealSubject();
    }
    
    void DoTask(){
        //...
        subject->process();
        
        //....
    }
};

class ISubject{
public:
    virtual void process();
};


//Proxy的设计
class SubjectProxy: public ISubject{
    
    
public:
    virtual void process(){
        //对RealSubject的一种间接访问
        //....
    }
};

class ClientApp{
    
    ISubject* subject;
    
public:
    
    ClientApp(){
        subject=new SubjectProxy();
    }
    
    void DoTask(){
        //...
        subject->process();
        
        //....
    }
};

15 Adapter 适配器

将一个类的接口转换成客户希望的另一个接口。Adapter 模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

//目标接口（新接口）
class ITarget{
public:
    virtual void process()=0;
};

//遗留接口（老接口）
class IAdaptee{
public:
    virtual void foo(int data)=0;
    virtual int bar()=0;
};

//遗留类型
class OldClass: public IAdaptee{
    //....
};

//对象适配器
class Adapter: public ITarget{ //继承
protected:
    IAdaptee* pAdaptee;//组合
    
public:
    
    Adapter(IAdaptee* pAdaptee){
        this->pAdaptee=pAdaptee;
    }
    
    virtual void process(){
        int data=pAdaptee->bar();
        pAdaptee->foo(data);
        
    }
    
    
};


//类适配器
class Adapter: public ITarget,
               protected OldClass{ //多继承
               //没有继承OldClass的接口，但是继承了实现
               //灵活性较差
}


int main(){
    IAdaptee* pAdaptee=new OldClass();
    
    
    ITarget* pTarget=new Adapter(pAdaptee);
    pTarget->process();
    
    
}

直接传入旧的对象pAdaptee，就可以直接通过pTarget使用了。

STL中

class stack{
    deqeue container;
    
};

class queue{
    deqeue container;
    
};

16 Mediator 中介者

用一个中介对象来封装（封装变化）一系列的对象交互。中介者使各对象不需要显式的相互引用（编译时以来->运行时依赖），从而使其耦合松散（管理变化），而且可以独立地改变它们之间的交互。——《设计模式》GoF

动机：
在软件构件过程中，经常会出现多个对象互相关联交互的情况，对象之间常常会维持一种复杂的引用关系，如果遇到一些需求的更改，这种直接的引用关系将面临不断的变化。
在这种情况下，我么可使用一个”中介对象“来管理对象间的关联关系，避免相互交互的对象的紧耦合引用关系，从而更好地抵御变化。

依赖解耦：
College依赖于Mediator，Mediator返回来又依赖ConcreteCollege1 和 ConcreteColleague

Facade模式是系统间的对象关联关系解耦，Mediator是系统内部的关联关系解耦。

状态变化：

17 State

18 Memento

数据结构：

19 Composite

20 Iterator

虚函数是运行时多态，在使用的时候由于需要经过虚函数，要从函数表里找对应的函数指针，所以代价较高。
stl中的迭代器是使用模板方法，是编译时多态，不经过虚函数，代价较小。且stl还支持前向、后向、双向、随机等等迭代器功能。

21 Chain of Resposibility

行为变化：

22 Command

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


class Command
{
public:
    virtual void execute() = 0;
};

class ConcreteCommand1 : public Command
{
    string arg;
public:
    ConcreteCommand1(const string & a) : arg(a) {}
    void execute() override
    {
        cout<< "#1 process..."<<arg<<endl;
    }
};

class ConcreteCommand2 : public Command
{
    string arg;
public:
    ConcreteCommand2(const string & a) : arg(a) {}
    void execute() override
    {
        cout<< "#2 process..."<<arg<<endl;
    }
};
        

class MacroCommand : public Command
{
    vector<Command*> commands;
public:
    void addCommand(Command *c) { commands.push_back(c); }
    void execute() override
    {
        for (auto &c : commands)
        {
            c->execute();
        }
    }
};
        

        
int main()
{

    ConcreteCommand1 command1(receiver, "Arg ###");
    ConcreteCommand2 command2(receiver, "Arg $$$");
    
    MacroCommand macro;
    macro.addCommand(&command1);
    macro.addCommand(&command2);
    
    macro.execute();

}

c++性能优先。command模式在c sharp和java中应用得更多。

23 Visitor

表示以恶搞作用域某对象结构中的各元素的操作。使得可以在不改变（稳定）各元素的类的前提下定义（扩展）作用域这些元素的新操作（变化）。——《设计模式》GoF

Visitor模式通过所谓双重分发（double dispatch）来实现在不更改（不添加新的操作-编译时），Element 类层次结构的前提下，在运行时透明地为类层次结构上的各个类动态添加新的操作（支持变化）。
所谓双重分发即Visitor模式中间包括了两个多态分发（注意其中的多态机制）：第一个为accept方法的多态辨析；第二个为visitElementX方法的多态辨析。
Visitor模式的最大缺点在于扩展类层次结构（增添新的Element子类），会导致Visitor类的改变。因此Vistor模式适用于“Element类层次结构稳定，而其中的操作却经常面临频繁改动”。

每次创建一个新的visitor，就相当于创建了一个新的方法。但是如果Element子类增加，那么也会打破开闭原则。

#include <iostream>
using namespace std;

class Visitor;


class Element
{
public:
    virtual void Func1() = 0;
    
    virtual void Func2(int data)=0;
    virtual void Func3(int data)=0;
    //...
    
    virtual ~Element(){}
};

class ElementA : public Element
{
public:
    void Func1() override{
        //...
    }
    
    void Func2(int data) override{
        //...
    }
    
};

class ElementB : public Element
{
public:
    void Func1() override{
        //***
    }
    
    void Func2(int data) override {
        //***
    }
    
};

#include <iostream>
using namespace std;

class Visitor;


class Element
{
public:
    virtual void accept(Visitor& visitor) = 0; //第一次多态辨析

    virtual ~Element(){}
};

class ElementA : public Element
{
public:
    void accept(Visitor &visitor) override {
        visitor.visitElementA(*this);
    }
    

};

class ElementB : public Element
{
public:
    void accept(Visitor &visitor) override {
        visitor.visitElementB(*this); //第二次多态辨析
    }

};


class Visitor{
public:
    virtual void visitElementA(ElementA& element) = 0;
    virtual void visitElementB(ElementB& element) = 0;
    
    virtual ~Visitor(){}
};

//==================================

//扩展1
class Visitor1 : public Visitor{
public:
    void visitElementA(ElementA& element) override{
        cout << "Visitor1 is processing ElementA" << endl;
    }
        
    void visitElementB(ElementB& element) override{
        cout << "Visitor1 is processing ElementB" << endl;
    }
};
     
//扩展2
class Visitor2 : public Visitor{
public:
    void visitElementA(ElementA& element) override{
        cout << "Visitor2 is processing ElementA" << endl;
    }
    
    void visitElementB(ElementB& element) override{
        cout << "Visitor2 is processing ElementB" << endl;
    }
};
        
    

        
int main()
{
    Visitor2 visitor;
    ElementB elementB;
    elementB.accept(visitor);// double dispatch
    
    ElementA elementA;
    elementA.accept(visitor);

    
    return 0;
}

Interpreter

给定一个语言，定义它得文法得一种表示，并定义一种解释器，这个解释器使用该表示来解释语言中的句子。——《设计模式》GoF

Interpreter 模式的应用场合是Interpreter 模式应用中的难点，只有满足“业务规则频繁变化，且类似的结构不断重复出现，并且容易抽象为语法规则的问题”才适合使用Interpreter模式。


#include <iostream>
#include <map>
#include <stack>

using namespace std;

class Expression {
public:
    virtual int interpreter(map<char, int> var)=0;
    virtual ~Expression(){}
};

//变量表达式
class VarExpression: public Expression {
    
    char key;
    
public:
    VarExpression(const char& key)
    {
        this->key = key;
    }
    
    int interpreter(map<char, int> var) override {
        return var[key];
    }
    
};

//符号表达式
class SymbolExpression : public Expression {
    
    // 运算符左右两个参数
protected:
    Expression* left;
    Expression* right;
    
public:
    SymbolExpression( Expression* left,  Expression* right):
        left(left),right(right){
        
    }
    
};

//加法运算
class AddExpression : public SymbolExpression {
    
public:
    AddExpression(Expression* left, Expression* right):
        SymbolExpression(left,right){
        
    }
    int interpreter(map<char, int> var) override {
        return left->interpreter(var) + right->interpreter(var);
    }
    
};

//减法运算
class SubExpression : public SymbolExpression {
    
public:
    SubExpression(Expression* left, Expression* right):
        SymbolExpression(left,right){
        
    }
    int interpreter(map<char, int> var) override {
        return left->interpreter(var) - right->interpreter(var);
    }
    
};



Expression*  analyse(string expStr) {
    
    stack<Expression*> expStack;
    Expression* left = nullptr;
    Expression* right = nullptr;
    for(int i=0; i<expStr.size(); i++)
    {
        switch(expStr[i])
        {
            case '+':
                // 加法运算
                left = expStack.top();
                right = new VarExpression(expStr[++i]);
                expStack.push(new AddExpression(left, right));
                break;
            case '-':
                // 减法运算
                left = expStack.top();
                right = new VarExpression(expStr[++i]);
                expStack.push(new SubExpression(left, right));
                break;
            default:
                // 变量表达式
                expStack.push(new VarExpression(expStr[i]));
        }
    }
   
    Expression* expression = expStack.top();

    return expression;
}

void release(Expression* expression){
    
    //释放表达式树的节点内存...
}

int main(int argc, const char * argv[]) {
    
    
    string expStr = "a+b-c+d-e";
    map<char, int> var;
    var.insert(make_pair('a',5));
    var.insert(make_pair('b',2));
    var.insert(make_pair('c',1));
    var.insert(make_pair('d',6));
    var.insert(make_pair('e',10));

    
    Expression* expression= analyse(expStr);
    
    int result=expression->interpreter(var);
    
    cout<<result<<endl;
    
    release(expression);
    
    return 0;
}

标签：...,23,int,void,virtual,public,设计模式,class
From： https://www.cnblogs.com/ixbwer/p/18001026

23种设计模式

八大原则

设计模式分类

”组件协作”模式——晚绑定

1 Template Method 模板模式

2 Strategy 策略模式

3 Observer/Event 观察者模式

单一职责模式——划清责任

4 Decorator 装饰模式

5 Bridge 桥模式

"对象创建”模式

6 Factory Method 工厂模式

7 Abstract Factory 抽象工厂

8 Prototype 原型模式

9 Builder 构建器

”对象性能“模式

11 Singleton

12 Flyweight 享元模式

接口隔离

13 Facade 门面模式

14 Proxy 代理模式

15 Adapter 适配器

16 Mediator 中介者

状态变化：

17 State

18 Memento

数据结构：

19 Composite

20 Iterator

21 Chain of Resposibility

行为变化：

22 Command

23 Visitor

Interpreter

相关文章

赞助商

阅读排行