設計模式

如何解決復雜性？

分解

核心思想：分而治之，將大問題分解為多個小問題，將復雜問題分解為多個簡單的問題。

抽象

核心思想：從高層次角度講，人們處理復雜性有一個通用的技術(shù)，及抽象。由于不能掌握全部的復雜對象，選擇護士他的非本質(zhì)細節(jié)，而去處理泛化和理想化的對象模型。

總結(jié)來說就是，復用最好的代碼就是復用性高。

面向?qū)ο笤O計原則

對象的概念：

• 從語言實現(xiàn)層面來看，對象封裝了代碼和數(shù)據(jù)。
• 從規(guī)格層面講，對象是一系列可被使用的公共接口。
• 從概念層面講，對象時某種擁有責任的抽象。

設計原則

依賴倒置原則（DIP）：

• 高層模塊（穩(wěn)定）不應該依賴于低層模塊（變化）二者都應該依賴于抽象（穩(wěn)定）。
• 抽象（穩(wěn)定）不應該依賴于實現(xiàn)細節(jié)（變化），實現(xiàn)細節(jié)應該依賴于抽象（穩(wěn)定）。

開放封閉原則（OCP）：

• 對擴展開放，對更改封閉。
• 類模塊應該是可擴展的，但是不可修改。

單一職責原則（SRP）：

• 一個類應該僅有一個引起它變化的原則。
• 變化的方向隱含著類的責任。

Liskov替換原則（LSP）：

• 子類必須能夠替換他們的基類。
• 繼承表達類型抽象

接口隔離原則（ISP）：

• 不應該強迫客戶程序依賴他們不用的方法。
• 接口應該小而完備。

優(yōu)先使用對象組合，而不是類繼承

• 類繼承通常為“白箱復用”，對象組合通常為“黑箱復用”。
• 繼承在某種程度上破壞了封裝性，子類父類耦合度很高。
• 而對象組合則只要求被組合的對象具有良好定義的接口，耦合度低。

封裝變化點：

• 使用封裝來創(chuàng)建對象之間的分界層，讓設計者可以在分界層的一側(cè)進行修改，而不會對另一側(cè)產(chǎn)生不良影響，從而實現(xiàn)層次間的松耦合。

針對接口與編碼，而不是針對實現(xiàn)編程：產(chǎn)業(yè)強盛的標志

• 不將變量類型聲明為某個特定的具體類，而是聲明為某個接口
• 客戶程序無需獲知對象的具優(yōu)類型，只需要知道對象所具有的接口。
• 減少系統(tǒng)中各部分的依賴關系從而實現(xiàn)“高內(nèi)聚、松耦合’的類型設計方案。

GOF-23模式分類

從目的來看：

• 創(chuàng)建型模式：將對象的部分創(chuàng)建工作延遲到子類或者其他對象，從而應對需求變化為對象創(chuàng)建時具體類型實現(xiàn)引來的沖擊。
• 結(jié)構(gòu)型模式：通過類繼承或者對象組合獲得更靈活的結(jié)構(gòu)，從而應對需求變化為對象的結(jié)構(gòu)帶來的沖擊。
• 行為型模式：通過類繼承或者對象組合來劃分類與對象間的職責，從而應對需求變化為多個交互的對象帶來的沖擊。

從范圍來看：

• 類模式處理類與子類的靜態(tài)關系。
• 對象模式處理對象間的動態(tài)關系。

C++設計模式

工廠模式

工廠模式：主要是封裝了對象的創(chuàng)建。

簡單工廠(Simple Factory)：

優(yōu)點：

1. 把對象的創(chuàng)建封裝在一個接口函數(shù)里面，通過傳入不同的標識，返回創(chuàng)建的對象。
2. 使用者不需要自己負責new對象，不用了解對象創(chuàng)建的詳細過程。

缺點：

1. 提供創(chuàng)建對象實例的接口函數(shù)不閉合，不能對修改關閉。

工廠方法(Factory Method)：

優(yōu)點：

1. 使用Factory基類，提供一個純虛函數(shù)（創(chuàng)建產(chǎn)品），定義派生類（具體產(chǎn)品的工廠）負責創(chuàng)建對應的產(chǎn)品，可以做到不同的產(chǎn)品在不同的工廠進行創(chuàng)建。能對現(xiàn)有工廠以及產(chǎn)品的修改關閉

缺點：

1. 忽略了產(chǎn)品之間的關聯(lián)關系，屬于一個產(chǎn)品簇的不應該放到不同的工廠里面去創(chuàng)建。不符合產(chǎn)品對象創(chuàng)建邏輯；
2. 工廠類太多，難以維護。

抽象工廠(Abstact Factory)

優(yōu)點：

1. 把現(xiàn)有關聯(lián)關系、屬于同一個產(chǎn)品簇的所有產(chǎn)品創(chuàng)建的接口函數(shù)放在一個抽象工廠里面，派生類（具體產(chǎn)品的工廠）應該負責創(chuàng)建該產(chǎn)品簇里面的所有產(chǎn)品。

這里使用了一個汽車生產(chǎn)的工廠示例，列舉了簡單工廠和工廠方法，并使用智能指針進行對象空間優(yōu)化回收。

簡單工廠和工廠方法

#include <iostream>
#include <string>
#include<memory>using namespace std;class Car
{
public:Car(string name):_name(name){}virtual void show() = 0; //定義純虛函數(shù)，子類必須實現(xiàn)protected:string _name;private:
};
class BMW:public Car
{
public:// 使用Car(name)類似于_name(name)，還是用了Car的_name，// 子類繼承父類的構(gòu)造函數(shù)可以參考 https://blog.csdn.net/aquapisces/article/details/104371658BMW(string name) : Car(name){};void show(){cout << "獲取了一輛寶馬汽車" << _name << endl;} 
protected : 
private:
};
class Audi : public Car
{
public:// 使用Car(name)類似于_name(name)，還是用了Car的_name，// 子類繼承父類的構(gòu)造函數(shù)可以參考 https://blog.csdn.net/aquapisces/article/details/104371658Audi(string name) : Car(name){};void show(){cout << "獲取了一輛奧迪汽車" << _name << endl;}protected:
private:
};// ------------------------------------------------------------------------------------------
/*
簡單工廠存在以下問題：開閉原則，新增一個汽車則需要修改很多代碼；BMW類和Audi類都在一個工廠里面生產(chǎn)
*/
enum CarType
{bmw,audi
};
class SimpleFactory
{
public:Car* createCar(CarType ct){switch (ct){case bmw:return new BMW("X1");case audi:return new Audi("A6");default:cout << "傳入工廠的參數(shù)不正確：" << ct << endl;break;}return nullptr;}
};
// ------------------------------------------------------------------------------------------
/*
工廠方法
*/
class Factory
{
public:virtual Car* createCar(string name) = 0;
};
class BMWFactory:public Factory
{
public:Car* createCar(string name){return new BMW(name);}
};
class AudiFactory : public Factory
{
public:Car *createCar(string name){return new Audi(name);}
};
// ------------------------------------------------------------------------------------------int main()
{// unique_ptr無法進行普通拷貝構(gòu)造和賦值unique_ptr<Car> p1=new BMW("X1");是錯誤的// 最原始的對象產(chǎn)生unique_ptr<Car> p1(new BMW("X1"));unique_ptr<Car> p2(new Audi("A6"));// 簡單工廠// unique_ptr<SimpleFactory> factory(new SimpleFactory());// unique_ptr<Car> p1(factory->createCar(bmw));// unique_ptr<Car> p2(factory->createCar(audi));// 工廠方法// unique_ptr<Factory> bmwFactory(new BMWFactory);// unique_ptr<Factory> audiFactory(new AudiFactory);// unique_ptr<Car> p1(bmwFactory->createCar("X6"));// unique_ptr<Car> p2(audiFactory->createCar("A8"));p1->show();p2->show();return 0;
}

抽象工廠方法

上一節(jié)中的工廠方法會存在一個問題，在定義了一個Factory抽象類后，每一個類將對應一個類的工廠，如BWM->BMWFactory，Audi->AudiFactory，這樣會導致一個問題，在生產(chǎn)一類產(chǎn)品時，如手機充電器和充電線，那么就又需要兩個工廠來實現(xiàn)，所以這樣就會導致工廠冗余。所以，提出了抽象工廠來解決這個問題，這里以汽車的生產(chǎn)部件為例進行說明：

#include <iostream>
#include <string>
#include<memory>using namespace std;class Car
{
public:Car(string name):_name(name){}virtual void show() = 0; //定義純虛函數(shù)，子類必須實現(xiàn)protected:string _name;private:
};
class BMW:public Car
{
public:// 使用Car(name)類似于_name(name)，還是用了Car的_name，// 子類繼承父類的構(gòu)造函數(shù)可以參考 https://blog.csdn.net/aquapisces/article/details/104371658BMW(string name) : Car(name){};void show(){cout << "獲取了一輛寶馬汽車" << _name << endl;} 
protected : 
private:
};
class Audi : public Car
{
public:// 使用Car(name)類似于_name(name)，還是用了Car的_name，// 子類繼承父類的構(gòu)造函數(shù)可以參考 https://blog.csdn.net/aquapisces/article/details/104371658Audi(string name) : Car(name){};void show(){cout << "獲取了一輛奧迪汽車" << _name << endl;}protected:
private:
};class Light
{
public:virtual void show() = 0;
};class BMWLight:public Light
{
public:void show(){cout << "BMW light!" << endl;}
};class AudiLight : public Light
{
public:void show(){cout << "Audi light!" << endl;}
};
/*
抽象工廠，對一組關聯(lián)關系的產(chǎn)品簇提供產(chǎn)品對象的統(tǒng)一創(chuàng)建。
有點類似于工廠方法
*/
class AbstractFactory
{
public:virtual Car *createCar(string name) = 0;virtual Light *createCarLight() = 0;
};
class BMWFactory : public AbstractFactory
{
public:Car *createCar(string name){return new BMW(name);}Light *createCarLight(){return new BMWLight();}
};
class AudiFactory : public AbstractFactory
{
public:Car *createCar(string name){return new Audi(name);}Light *createCarLight(){return new AudiLight();}
};int main()
{// 抽象工廠方法unique_ptr<AbstractFactory> bmwFactory(new BMWFactory);unique_ptr<AbstractFactory> audiFactory(new AudiFactory);unique_ptr<Car> p1(bmwFactory->createCar("X6"));unique_ptr<Car> p2(audiFactory->createCar("A8"));unique_ptr<Light> l1(bmwFactory->createCarLight());unique_ptr<Light> l2(audiFactory->createCarLight());p1->show();p2->show();l1->show();l2->show();return 0;
}

代理模式

代理（proxy）模式：通過代理類，來控制實際對象的訪問權(quán)限。其實也就是定義一個虛基類，子類繼承虛基類實現(xiàn)不同級別對象的實現(xiàn)，可以看以下類似代碼：

#include <iostream>
#include <string>
#include<memory>using namespace std;class VideoSite
{
public:virtual void freeMovie() = 0;virtual void vipMovie() = 0;virtual void ticketMovie() = 0;
};
class FixBugVideoSite:public VideoSite
{// 不同的用戶的訪問權(quán)限可能不夠，所以下面三個函數(shù)有些對象不能調(diào)用void freeMovie(){cout << "觀看免費電影" << endl;}void vipMovie(){cout << "觀看vip電影" << endl;}void ticketMovie(){cout << "觀看電影券電影" << endl;}
};// 代理類，用于代理FixBugVideoSite
class FreeVideoSiteProxy:public VideoSite
{
public:FreeVideoSiteProxy(){pVideo = new FixBugVideoSite();}~FreeVideoSiteProxy(){if(pVideo!=nullptr){delete pVideo;}pVideo = nullptr;}void freeMovie(){pVideo->freeMovie();}void vipMovie(){cout << "您目前只是普通用戶，需要升級成vip才能觀看vip電影" << endl;}void ticketMovie(){cout << "您目前只是普通用戶，需要購買電影券才能觀看電影" << endl;}private:VideoSite *pVideo;
};
class VipVideoSiteProxy : public VideoSite
{
public:VipVideoSiteProxy(){pVideo = new FixBugVideoSite();}~VipVideoSiteProxy(){if (pVideo != nullptr){delete pVideo;}pVideo = nullptr;}void freeMovie(){pVideo->freeMovie();}void vipMovie(){pVideo->vipMovie();}void ticketMovie(){cout << "您目前只是普通用戶，需要購買電影券才能觀看電影" << endl;}private:VideoSite *pVideo;
};
int main()
{// unique_ptr<VideoSite> p1(new FreeVideoSiteProxy());unique_ptr<VideoSite> p1(new VipVideoSiteProxy());p1->freeMovie();p1->vipMovie();p1->ticketMovie();return 0;
}

觀察者模式

行為型模式：主要關注的是對象之間的通信。

以觀察者-監(jiān)聽者模式（發(fā)布-訂閱模式）設計模式：主要關注的是對象的一對多的關系，也就是多個對象都依賴一個對象，當該對象的狀態(tài)發(fā)生改變時，其他對象都能夠結(jié)束到相應的通知。

ps：一組數(shù)據(jù)改變（數(shù)據(jù)對象）->通過這一組數(shù)據(jù)->曲線圖（對象1）/柱狀圖（對象2）/圓餅圖（對象3）。當數(shù)據(jù)對象改變時，對象1、對象2、對象3應該及時的收到相應的通知。

#include <iostream>
#include <string>
#include<list>
#include<unordered_map>using namespace std;
/**
觀察者模式/訂閱模式：當一個對象發(fā)生改變時，會通知其他對象去處理對象的事件。
*/
class Observer
{
public:virtual void handle(int msgid) = 0;
};
class Observer1:public Observer
{void handle(int msgid){switch (msgid){case 1:cout << "observer1 recv 1 msg." << endl;break;case 2:cout << "observer1 recv 2 msg." << endl;break;default:cout << "observer1 recv unknow msg." << endl;break;}}
};
class Observer2 : public Observer
{void handle(int msgid){switch (msgid){case 3:cout << "observer2 recv 3 msg." << endl;break;case 2:cout << "observer2 recv 2 msg." << endl;break;default:cout << "observer2 recv unknow msg." << endl;break;}}
};
class Observer3 : public Observer
{void handle(int msgid){switch (msgid){case 1:cout << "observer3 recv 1 msg." << endl;break;case 3:cout << "observer3 recv 3 msg." << endl;break;default:cout << "observer3 recv unknow msg." << endl;break;}}
};
class Subjects
{
public:// 給主題添加觀察者對象void addObserver(Observer* obser,int msgid){// 和下面的操作一致，如果存在msgid為key的情況就直接插入，沒有就創(chuàng)建一個并插入_submap[msgid].push_back(obser);/**// 查找map中是否存在有key為msgid的值auto it = _submap.find(msgid);if(it != _submap.end()){it->second.push_back(obser);}else{list<Observer *> olist;olist.push_back(obser);_submap.insert(make_pair(msgid, olist));}*/}// 主題檢測發(fā)生改變，通知相應的觀察者對象處理事件void dispatch(int msg){auto it = _submap.find(msg);if (it != _submap.end()){for(Observer* pObser:it->second){pObser->handle(msg);}}}
private:unordered_map<int, list<Observer *>> _submap;
};
int main()
{Subjects sub;Observer *p1 = new Observer1();Observer *p2 = new Observer2();Observer *p3 = new Observer3();sub.addObserver(p1, 1);sub.addObserver(p2, 3);sub.addObserver(p3, 1);sub.addObserver(p3, 2);sub.addObserver(p1, 3);sub.dispatch(2);return 0;
}

適配器模式

適配器模式：讓不兼容的接口可以在一起工作。

下方使用C++實現(xiàn)了一個電腦播放投影視頻的例子，電腦僅僅支持VGA接口，如何實現(xiàn)HDMI接口轉(zhuǎn)化成VGA來適配電腦使用。也就是如何實現(xiàn)一個VGA和HEMI類的轉(zhuǎn)化接口。

#include <iostream>
#include <string>using namespace std;class VGA
{
public:virtual void play() = 0;
};
class TV01:public VGA
{
public:void play() { cout << "通過VGA接口連接投影儀，進行視頻播放！" << endl; }
};class HDMI
{
public:virtual void play() = 0;
};
class TV02 : public HDMI
{
public:void play() { cout << "通過HDMI接口連接投影儀，進行視頻播放！" << endl; }
};// 一定要繼承原來的類
class VGA2HDMIAdapter:public VGA
{
public:VGA2HDMIAdapter(HDMI* p):phdmi(p){}void play() { phdmi->play(); }private:HDMI *phdmi;
};
class Computer
{
public:// 由于電腦只支持VGA接口，所以該方法的參數(shù)也只支持VGA接口的指針/引用void playVideo(VGA *pVGA) { pVGA->play(); }
};int main()
{// HDMI和VGA無法進行互相轉(zhuǎn)化，電腦如何使用HDMI的play方法？/*1、換一個支持HDMI的電腦，也就是對Computer類進行重構(gòu)，叫做代碼重構(gòu)。2、使用一個適配器（轉(zhuǎn)化頭），把VGA類轉(zhuǎn)化為HDMI類，叫做添加適配器類。*/Computer computer;computer.playVideo(new TV01());computer.playVideo(new VGA2HDMIAdapter(new TV02()));return 0;
}

裝飾器模式

裝飾器（decorate）模式和代理模式類似。代理模式也就是定義委托類和代理類繼承抽象類，并重寫函數(shù)方法，通過在代理類中使用委托類的對象調(diào)用不同級別代理的方法訪問。

裝飾器主要是增加現(xiàn)有類的功能，但是添加現(xiàn)有類的一個方法還有一個方法，就是新建一個子類。如果每次新建一個功能都需要新建一個子類的話，那么代碼中就會有很多的子類被添加進來。

以下實現(xiàn)了一個汽車裝飾類的代碼實現(xiàn)：

#include <iostream>
#include <string>using namespace std;class Car
{
public:virtual void show() = 0;
};
class BMW : public Car
{
public:void show() { cout << "這是一輛寶馬汽車！有基本配置"; }
};
class Audi : public Car
{
public:void show() { cout << "這是一輛奧迪汽車！有基本配置"; }
};
class Benc : public Car
{
public:void show() { cout << "這是一輛奔馳汽車！有基本配置"; }
};
// 裝飾器
class CarDecorator01 : public Car
{
public:CarDecorator01(Car *p) : pCar(p){};void show(){pCar->show();cout << ",輔助駕駛";}
private: Car *pCar;
};
class CarDecorator02 : public Car
{
public:CarDecorator02(Car *p) : pCar(p){};void show(){pCar->show();cout << ",自動校正";}private:Car *pCar;
};
class CarDecorator03 : public Car
{
public:CarDecorator03(Car *p) : pCar(p){};void show(){pCar->show();cout << ",車道偏離";}private:Car *pCar;
};
int main()
{Car *p1 = new CarDecorator01(new BMW());p1 = new CarDecorator02(p1);p1->show();cout << endl;Car *p2 = new CarDecorator02(new Audi());p2->show();cout << endl;Car *p3 = new CarDecorator03(new Benc());p3->show();cout << endl;return 0;
}

單例模式

常見的類創(chuàng)建一個對象，便會得到一個新的對象。而單例模式則有些不同。

單例模式：一個類不管創(chuàng)建多少次對象，永遠只能得到該類型一個對象的實例。可以查看C++實現(xiàn)MySQL數(shù)據(jù)庫連接池中的線程池獲取代碼，將線程池定義為靜態(tài)成員方法和靜態(tài)成員變量，導致其處于靜態(tài)變量區(qū)，只需要初始化一次。類似的日志模塊應該也可以使用單例模式。

餓漢式單例模式：還沒有獲取實例對象，實例對象就已經(jīng)產(chǎn)生了。
懶漢式單例模式：唯一的實例對象，直到第一次獲取它的時候才產(chǎn)生。

下面介紹了兩種單例模式的代碼設計，其中提供了兩種懶漢式單例模式的示例：

#include <iostream>
#include <string>
#include<mutex>
using namespace std;// 餓漢式單例模式，線程安全的
class HungrySingleton
{
public:// 因為其不能依賴對象，所以要定義成靜態(tài)成員方法，獲取類的唯一實例對象的方法static HungrySingleton* getSingleton(){return &instance;}
private:// 單例模式，不允許用戶new對象，所以需要使用構(gòu)造函數(shù)私有化HungrySingleton(){}static HungrySingleton instance;// 將拷貝構(gòu)造函數(shù)和賦值操作符重載進行刪除，使其不能完成對象創(chuàng)建，只能依賴getSingleton過去唯一的實例化對象HungrySingleton& operator=(const HungrySingleton &) = delete;HungrySingleton(const HungrySingleton &) = delete;
};
// 類內(nèi)定義，類外初始化，更多static初始化查看 https://blog.csdn.net/sevenjoin/article/details/81772792
// 靜態(tài)成員在數(shù)據(jù)段，在main函數(shù)之前就創(chuàng)建了，如果不使用的話，這個資源就浪費了
HungrySingleton HungrySingleton::instance;mutex lazySingletonMtx;// 懶漢式單例模式，線程安全的
class LazySingleton
{
public:// 因為其不能依賴對象，所以要定義成靜態(tài)成員方法，獲取類的唯一實例對象的方法// 可重入函數(shù)的概念？一個線程還沒執(zhí)行完，該函數(shù)不能被另一個線程執(zhí)行，也就是線程互斥static LazySingleton *getSingleton(){   if(instance==nullptr){lock_guard<mutex> lck(lazySingletonMtx); // 所以多線程環(huán)境下需要加鎖和雙重判斷/*不是線程安全，下面這個instance = new LazySingleton()需要執(zhí)行-：開辟內(nèi)存、構(gòu)造對象、instance賦值*/if(instance==nullptr){ // 雙重判斷，防止兩個線程同時進入上層的if判斷中instance = new LazySingleton();}}return instance;}private:// 單例模式，不允許用戶new對象，所以需要使用構(gòu)造函數(shù)私有化LazySingleton(){}static LazySingleton*volatile instance;// 將拷貝構(gòu)造函數(shù)和賦值操作符重載進行刪除，使其不能完成對象創(chuàng)建，只能依賴getSingleton過去唯一的實例化對象LazySingleton &operator=(const LazySingleton &) = delete;LazySingleton(const LazySingleton &) = delete;
};
// 類內(nèi)定義，類外初始化，更多static初始化查看 https://blog.csdn.net/sevenjoin/article/details/81772792
// 靜態(tài)成員在數(shù)據(jù)段，在main函數(shù)之前就創(chuàng)建了，如果不使用的話，這個資源就浪費了
LazySingleton*volatile LazySingleton::instance=nullptr;// 懶漢式單例模式，線程安全的
class LazySingleton2
{
public:// 因為其不能依賴對象，所以要定義成靜態(tài)成員方法，獲取類的唯一實例對象的方法// 可重入函數(shù)的概念？一個線程還沒執(zhí)行完，該函數(shù)不能被另一個線程執(zhí)行，也就是線程互斥static LazySingleton2 *getSingleton(){// 靜態(tài)對象，運行到這個函數(shù)才開始初始化// 函數(shù)靜態(tài)局部變量的初始化，在匯編指令上已經(jīng)自動添加線程互斥指令static LazySingleton2 instance;return &instance;}private:// 單例模式，不允許用戶new對象，所以需要使用構(gòu)造函數(shù)私有化LazySingleton2(){}// 將拷貝構(gòu)造函數(shù)和賦值操作符重載進行刪除，使其不能完成對象創(chuàng)建，只能依賴getSingleton過去唯一的實例化對象LazySingleton2 &operator=(const LazySingleton2 &) = delete;LazySingleton2(const LazySingleton2 &) = delete;
};int main()
{HungrySingleton *p1 = HungrySingleton::getSingleton();HungrySingleton *p2 = HungrySingleton::getSingleton();HungrySingleton *p3 = HungrySingleton::getSingleton();cout << p1 << " " << p2 << " " << p3 << endl; // 0x407030 0x407030 0x407030LazySingleton *p4 = LazySingleton::getSingleton();LazySingleton *p5 = LazySingleton::getSingleton();LazySingleton *p6 = LazySingleton::getSingleton();cout << p4 << " " << p5 << " " << p6 << endl; // 0x25d2430 0x25d2430 0x25d2430// HungrySingleton t = *p1; // 拷貝構(gòu)造函數(shù)私有化之后就不能完成拷貝構(gòu)造了return 0;
}

一般情況下第二種懶漢式單例模式用的比較多，也更簡單，在靜態(tài)成員方法中定義靜態(tài)成員對象。