C++常见的设计模式

1、工厂模式：

#include<iostream>
using namespace std;
class Product {
public:
    virtual void show() = 0;
};

class ConcreteProduct : public Product {
public:
    void show() override {
        cout << "ConcreteProduct" << endl;
    }
};

class Factory {
public:
    virtual Product* createProduct() = 0;
};

class ConcreteFactory : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProduct();
    }
};
int main()
{
    return 0;
}

2、单例模式：

class Singleton {
private:
    static Singleton* instance;
    Singleton() {}

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;

int main()
{
    return 0;
}

3、观察者模式

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

class Observer {
public:
    virtual void update() = 0;
};
class Subject {
protected:
    list<Observer*> observers;

public:
    virtual void attach(Observer* observer) {
        observers.push_back(observer);
    }

    virtual void detach(Observer* observer) {
        observers.remove(observer);
    }

    virtual void notify() {
        for (auto observer : observers) {
            observer->update();
        }
    }
};

class ConcreteSubject : public Subject {
    // ...
};

class ConcreteObserver : public Observer {
public:
    void update() override {
        cout << "ConcreteObserver updated." << endl;
    }
};
int main()
{
    return 0;
}

 3、观察者模式2

1. 概述

　　有时被称作发布/订阅模式，观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

2. 解决的问题

　　将一个系统分割成一个一些类相互协作的类有一个不好的副作用，那就是需要维护相关对象间的一致性。我们不希望为了维持一致性而使各类紧密耦合，这样会给维护、扩展和重用都带来不便。观察者就是解决这类的耦合关系的。

3. 模式中的角色

　　3.1 抽象主题（Subject）：它把所有观察者对象的引用保存到一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象。

　　3.2 具体主题（ConcreteSubject）：将有关状态存入具体观察者对象；在具体主题内部状态改变时，给所有登记过的观察者发出通知。

　　3.3 抽象观察者（Observer）：为所有的具体观察者定义一个接口，在得到主题通知时更新自己。

　　3.4 具体观察者（ConcreteObserver）：实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题状态协调。

看代码：

main()，

IObservable，被观察者接口

CHanFeiZiObservable，被观察者韩非子

IObserver，观察者接口

CLiSiObserver，观察者李斯

CZhouSiObserver观察者周斯

说明：将观察者聚集到被观察者韩非子身边，韩非子的每一个举动都会通知给观察者，如李斯或周斯。

注意：最多允许一个对象既是观察者也是被观察者。就像数据库中的触发器一样，成为一个复杂的链就很难维护了。观察者类似于委托的处理方式。

//IObservable.h

#pragma once
#include "IObserver.h"
#include <</span>iostream>
using std::string;
class IObservable
{
public:
   IObservable(void)
    {
    }
    virtual ~IObservable(void)
    {
    }
    virtual void AddObserver(IObserver *pObserver) = 0;
    virtual void DeleteObserver(IObserver *pObserver) = 0;
    virtual void NotifyObservers(string context) = 0;
};

//HanFeiziObservable.h

#pragma once
#include "iobservable.h"
#include "IObserver.h"
#include
using std::vector;
class CHanFeiziObservable :
    public IObservable
{
public:
   CHanFeiziObservable(void);
   ~CHanFeiziObservable(void);
    void AddObserver(IObserver *pObserver);
    void DeleteObserver(IObserver *pObserver);
    void NotifyObservers(string context);
    void HaveBreakfast();
    void HaveFun();
private:
    vector m_observerList;
    typedef vector::const_iterator ObserverList_C_iterator;
};

//HanFeiziObservable.cpp

#include "StdAfx.h"
#include "HanFeiziObservable.h"
#include <</span>iostream>
using std::string;
using std::cout;
using std::endl;
CHanFeiziObservable::CHanFeiziObservable(void)
{
}
CHanFeiziObservable::~CHanFeiziObservable(void)
{
}
void CHanFeiziObservable::AddObserver( IObserver *pObserver )
{
   m_observerList.push_back(pObserver);
}
void CHanFeiziObservable::DeleteObserver( IObserver *pObserver )
{
   ObserverList_C_iterator it = m_observerList.begin();
    for (; it != m_observerList.end(); it++)
    {
       string name = (*it)->GetName();
       if (name.compare(pObserver->GetName()) == 0)
       {
         //找到了删除。

m_observerList.erase(it);

break;

      }
   }
}
void CHanFeiziObservable::NotifyObservers( string context )
{
   ObserverList_C_iterator it = m_observerList.begin();
   for (; it != m_observerList.end(); it ++)
   {
      (*it)->Update(context);
   }
}
void CHanFeiziObservable::HaveBreakfast()
{
   cout << "韩非子：开始吃饭了..." << endl;

   this->NotifyObservers("韩非子在吃饭");
}
void CHanFeiziObservable::HaveFun()
{
   cout << "韩非子：开始娱乐了..." << endl;

   this->NotifyObservers("韩非子在娱乐");
}

//IObserver.h

#pragma once
#include <</span>iostream>
using std::string;
class IObserver
{
public:
   IObserver(string _name)
    {
      this->m_name = _name;
    }
    virtual ~IObserver(void)
    {
    }
    virtual void Update(string context) = 0;
    virtual string GetName() = 0;//为c++单独增加的函数，用于删除时查找观察者。
protected:
    string m_name;
};

//LiSiObserver.h

#pragma once
#include "iobserver.h"
#include "iostream"
using std::string;
class CLiSiObserver :
    public IObserver
{
public:
   CLiSiObserver(void);
   ~CLiSiObserver(void);
    void Update(string context);
    string GetName();
private:
    void ReportToQinShiHuang(string report);
};

//LiSiObserver.cpp

#include "StdAfx.h"
#include "LiSiObserver.h"
#include <</span>iostream>
using std::cout;
using std::endl;
using std::string;
CLiSiObserver::CLiSiObserver(void) : IObserver("李斯")
{
}
CLiSiObserver::~CLiSiObserver(void)
{
}
void CLiSiObserver::Update( string context )
{
    cout << "李斯：观察到韩非子活动，开始向老板汇报了..." << endl;
   this->ReportToQinShiHuang(context);
    cout << "李斯：汇报完毕，秦老板赏给他两个萝卜吃吃..." << endl;
}
void CLiSiObserver::ReportToQinShiHuang( string report )
{
    cout << "李斯：报告，秦老板！韩非子有活动了--->" << report.c_str() << endl;
}
string CLiSiObserver::GetName()
{
    return m_name;
}

//ZhouSiObserver.h

#pragma once
#include "iobserver.h"
#include
using std::string;
class CZhouSiObserver :
    public IObserver
{
public:
   CZhouSiObserver(void);
   ~CZhouSiObserver(void);
    void Update(string context);
    string GetName();
private:
    void Cry(string report);
};

//ZhouSiObserver.cpp

#include "StdAfx.h"
#include "ZhouSiObserver.h"
#include "iostream"
using std::cout;
using std::endl;
using std::string;
CZhouSiObserver::CZhouSiObserver(void) : IObserver("周斯")
{
}
CZhouSiObserver::~CZhouSiObserver(void)
{
}
void CZhouSiObserver::Update( string context )
{
    cout << "周斯：观察到韩非子活动，自己也开始活动了..." << endl;
   this->Cry(context);
    cout << "周斯：真真的哭了..." << endl;
}
void CZhouSiObserver::Cry( string report )
{
    cout << "周斯：因为" << report.c_str() << ", ————所以我悲伤呀！" << endl;

}
string CZhouSiObserver::GetName()
{
    return m_name;
}

// Observer.cpp 
#include "stdafx.h"
#include "HanFeiZi.h"
#include "LiSi.h"
#include "HanFeiZiNew.h"
#include "HanFeiziObservable.h"
#include "LiSiObserver.h"
#include "ZhouSiObserver.h"
#include <<span style="font-family: verdana, Arial, helvetica, sans-seriff;">iostream>

using std::cout;
using std::endl;
using std::string;

void DoNew()
{
   //IHanFeiZi.h, HanFeiZiNew.h, ILiSi.h, LiSi.h
   // cout << "----------用新的方法试试----------" << endl;

   //CHanFeiZiNew hanfeizi;

   //hanfeizi.HaveBreakfast();

   //hanfeizi.HaveFun();
}


void DoNewNew()
{
   //IObservable.h, HanfeiziObservable.h, IObserver.h, LiSiObserver.h
    cout << "----------用更新的方法再试试----------" << endl;
    IObserver *pLiSi = new CLiSiObserver();
    IObserver *pZhouSi = new CZhouSiObserver();

   CHanFeiziObservable *pHanFeiZi = new CHanFeiziObservable();

   pHanFeiZi->AddObserver(pLiSi);
   pHanFeiZi->AddObserver(pZhouSi);
   pHanFeiZi->HaveBreakfast();

    delete pLiSi;
    pLiSi = NULL;
    delete pHanFeiZi;
    pHanFeiZi = NULL;
}

int main( )
{
   //把李斯这个类聚集到韩非子这个类上，这样的话耦合度太高了，还是用更抽象的方式。
   DoNew();

   //更抽象的方式，想要观察韩非子的人多了去了，不可能只允许李斯观察。
   DoNewNew();

    return 0;
}