點擊鏈接閱讀原文，獲取更多技術(shù)內(nèi)容：

(資料圖)

本文從設(shè)計原則、創(chuàng)建型模式、結(jié)構(gòu)型模式、行為模式四個方向講述C++的設(shè)計模式。

作者 | 恒索

來源 | 阿里開發(fā)者公眾號

設(shè)計原則

單一職責(zé)原則

定義：單一職責(zé)原則[1]，所謂職責(zé)是指類變化的原因。如果一個類有多于一個的動機被改變，那么這個類就具有多于一個的職責(zé)。而單一職責(zé)原則就是指一個類或者模塊應(yīng)該 有且只有一個改變的原因。

bad case ：IPhone類承擔(dān)了協(xié)議管理（Dial、HangUp）、數(shù)據(jù)傳送（Chat）。

good case：

里式替換原則

定義：里氏代換原則[2](Liskov Substitution Principle LSP)，任何 基類 可以出現(xiàn)的地方， 子類一定可以出現(xiàn)。

bad case ：ToyGun繼承了AbstractGun，但Solider在調(diào)用KillEnemy()時會報錯（ToyGun無法KillEnemy），即ToyGun無法完全行使AbstractGun的職責(zé)。

good case： AbstractToy中將聲音、形狀都委托給AbstractGun處理。

如果子類不能完整地實現(xiàn)父類的方法，或者父類的某些方法在子類中已經(jīng)發(fā)生“畸變”，則建議斷開父子繼承關(guān)系，采用依賴、聚集、組合等關(guān)系代替。

依賴倒置原則

定義：依賴倒置原則[3]（Dependence Inversion Principle）是程序要 依賴于抽象接口，不要依賴于具體實現(xiàn)。 簡單的說就是要求對抽象進行編程，不要對實現(xiàn)進行編程，這樣就降低了客戶與實現(xiàn)模塊間的耦合。

bad case： Driver強依賴于奔馳車。

good case：

接口隔離原則

定義： 接口隔離原則[4]，客戶端不應(yīng)該依賴它不需要的接口。一個類對另一個類的 依賴 應(yīng)該建立在 最小的接口上 。

bad case： 星探尋找美女的類圖，其中IpettyGirl過于龐大，容納過多可變的因素。

good case： 通過拆分接口，提高了靈活性、可維護性。

迪米特法則

定義：迪米特法則[5]（Law of Demeter）又叫作 最少知識原則 （The Least Knowledge Principle），一個類對于其他類知道的越少越好，就是說一個對象應(yīng)當(dāng)對其他對象有盡可能少的了解，只和朋友通信，不和陌生人說話。

bad case： Teacher要求GroupLeader清點女生的數(shù)量，這里Teacher不應(yīng)該依賴于Gril。

good case：

開閉原則

定義：開閉原則[6]，在面向?qū)ο缶幊填I(lǐng)域中，規(guī)定“軟件中的對象（類，模塊，函數(shù)等等）應(yīng)該對于 擴展是開放 的，但是對于 修改是封閉 的”。

以一個書店售書類圖為例，當(dāng)在書店要增加一個打折操作時。

bad case：修改實現(xiàn)類，在IBook上增加一個方法GetOffPrice() good case：通過擴展實現(xiàn)變化，增加一個子類OffNovelBook

創(chuàng)建型模式

工廠方法

定義一個用于創(chuàng)建對象的接口 Product* CreateProduct() ，讓子類決定實例化哪一個類。工廠方法模式讓類的實例化延遲到子類中進行，從而避免了在父類中創(chuàng)建對象時出現(xiàn)類名稱緊耦合的問題，同時提高了代碼的可擴展性和可維護性。（工廠方法的好處就是 解耦 ，當(dāng)我們修改了具體的類，對調(diào)用方而言完全不用修改）

class Product {    // 抽象產(chǎn)品public:  virtual void Method() = 0;};class ConcreteProduct1 : public Product {public:  void Method() { cout << \"ConcreteProduct1\" << endl; }};class ConcreteProduct2 : public Product {public:  void Method() { cout << \"ConcreteProduct2\" << endl; }};class Factory {    // 抽象工廠public:  virtual Product* CreateProduct() = 0;};class ConcreteFactory1 : public Factory {public:  Product* CreateProduct() {return new ConcreteProduct1(); }};class ConcreteFactory2 : public Factory {public:  Product* CreateProduct() {return new ConcreteProduct2(); }};int main () {  Factory *factory1 = new ConcreteFactory1();  Factory *factory2 = new ConcreteFactory2();  Product *product1 = factory1->CreateProduct();  Product *product2 = factory2->CreateProduct();  product1->Method();  product2->Method();}

抽象工廠

為創(chuàng)建一組相關(guān)或相互依賴的對象提供一個接口，而且無須指定他們的具體類。（工廠方法模式針對的是一個產(chǎn)品等級結(jié)構(gòu)；而抽象工廠模式針對的是 多個產(chǎn)品等級結(jié)構(gòu) 。抽象工廠模式主要用來實現(xiàn)生產(chǎn)一系列的產(chǎn)品。）

class AbstractProductA { public:  virtual ~AbstractProductA(){};  virtual std::string FunctionA() const = 0;};class ProductA1 : public AbstractProductA { public:  std::string FunctionA() const override { return \"The result of the product A1.\"; }};class ProductA2 : public AbstractProductA {  std::string FunctionA() const override { return \"The result of the product A2.\"; }};class AbstractProductB { public:  virtual ~AbstractProductB(){};  virtual std::string FunctionB() const = 0;};class ProductB1 : public AbstractProductB { public:  std::string FunctionB() const override { return \"The result of the product B1.\"; }};class ProductB2 : public AbstractProductB { public:  std::string FunctionB() const override { return \"The result of the product B2.\"; }};class AbstractFactory { public:  virtual AbstractProductA *CreateProductA() const = 0;  virtual AbstractProductB *CreateProductB() const = 0;};class Factory1 : public AbstractFactory { public:  AbstractProductA *CreateProductA() const override { return new ProductA1(); }  AbstractProductB *CreateProductB() const override { return new ProductB1(); }};class Factory2 : public AbstractFactory { public:  AbstractProductA *CreateProductA() const override { return new ProductA2(); }  AbstractProductB *CreateProductB() const override { return new ProductB2(); }};void Client(const AbstractFactory &factory) {  const AbstractProductA *productA = factory.CreateProductA();  const AbstractProductB *productB = factory.CreateProductB();  std::cout << productA->FunctionA() << \"
\";  std::cout << productB->FunctionB() << \"
\";  delete productA;  delete productB;}int main() {  Factory1 *f1 = new Factory1();  Client(*f1);  delete f1;  Factory2 *f2 = new Factory2();  Client(*f2);  delete f2;  return 0;}

生成器/建造者

將一個復(fù)雜對象的構(gòu)建與它的表示分離，使得同樣的構(gòu)建過程可以創(chuàng)建不同的表示。（建造者模式關(guān)注的是 零件類型 和裝配工藝（ 順序 ））

class Product1{public:    std::vectormParts;    void ListParts()const{        std::cout << \"Product parts: \";        for (size_t i=0;imProduct->mParts.push_back(\"PartA1\"); }    void ProducePartB()const override{ this->mProduct->mParts.push_back(\"PartB1\"); }    void ProducePartC()const override{ this->mProduct->mParts.push_back(\"PartC1\"); }    Product1* GetProduct() {         Product1* result= mProduct;        Reset();        return result;     }};class Director {    Builder* mbuilder;public:    void set_builder(Builder* builder){ mbuilder = builder; }    void BuildMinimalViableProduct(){ mbuilder->ProducePartA(); }    void BuildFullFeaturedProduct(){        mbuilder->ProducePartA();        mbuilder->ProducePartB();        mbuilder->ProducePartC();    }};void ClientCode(Director& director){    ConcreteBuilder1* builder = new ConcreteBuilder1();    director.set_builder(builder);    std::cout << \"Standard basic product:
\";     director.BuildMinimalViableProduct();    Product1* p= builder->GetProduct();    p->ListParts();    delete p;    std::cout << \"Standard full featured product:
\";     director.BuildFullFeaturedProduct();    p= builder->GetProduct();    p->ListParts();    delete p;    // Remember, the Builder pattern can be used without a Director class.    std::cout << \"Custom product:
\";    builder->ProducePartA();    builder->ProducePartC();    p=builder->GetProduct();    p->ListParts();    delete p;    delete builder;}int main(){    Director* director= new Director();    ClientCode(*director);    delete director;    return 0;    }

原型

用原型實例指定創(chuàng)建對象的種類，并且通過 拷貝 這些原型創(chuàng)建新的對象。（原型模式實現(xiàn)的是一個Clone 接口，注意是接口，也就是基于 多態(tài)的 Clone 虛函數(shù) 。）

class Prototype { protected:  string mPrototypeName;  float mPrototypeField;public:  Prototype() {}  Prototype(string prototypeName)      : mPrototypeName(prototypeName) {  }  virtual ~Prototype() {}  virtual Prototype *Clone() const = 0;  virtual void Function(float prototype_field) {    this->mPrototypeField = prototype_field;    std::cout << \"Call Function from \" << mPrototypeName << \" with field : \" << prototype_field << std::endl;  }};class ConcretePrototype1 : public Prototype {private:  float mConcretePrototypeField;public:  ConcretePrototype1(string prototypeName, float concretePrototypeField)      : Prototype(prototypeName), mConcretePrototypeField(concretePrototypeField) {  }  Prototype *Clone() const override {    return new ConcretePrototype1(*this);  }};class ConcretePrototype2 : public Prototype {private:  float mConcretePrototypeField;public:  ConcretePrototype2(string prototypeName, float concretePrototypeField)      : Prototype(prototypeName), mConcretePrototypeField(concretePrototypeField) {  }  Prototype *Clone() const override {    return new ConcretePrototype2(*this);  }};class PrototypeFactory {private:  std::unordered_map>mPrototypes;public:  PrototypeFactory() {    mPrototypes[Type::PROTOTYPE_1] = new ConcretePrototype1(\"PROTOTYPE_1 \", 50.f);    mPrototypes[Type::PROTOTYPE_2] = new ConcretePrototype2(\"PROTOTYPE_2 \", 60.f);  }  ~PrototypeFactory() {    delete mPrototypes[Type::PROTOTYPE_1];    delete mPrototypes[Type::PROTOTYPE_2];  }  Prototype *CreatePrototype(Type type) {    return mPrototypes[type]->Clone();  }};void Client(PrototypeFactory &prototypeFactory) {  std::cout << \"Let"s create a Prototype 1
\";  Prototype *prototype = prototypeFactory.CreatePrototype(Type::PROTOTYPE_1);  prototype->Function(90);  delete prototype;  std::cout << \"Let"s create a Prototype 2 
\";  prototype = prototypeFactory.CreatePrototype(Type::PROTOTYPE_2);  prototype->Function(10);  delete prototype;}int main() {  PrototypeFactory *prototypeFactory = new PrototypeFactory();  Client(*prototypeFactory);  delete prototypeFactory;  return 0;}

單例

單例模式是指在整個系統(tǒng)生命周期內(nèi)，保證 一個類只能產(chǎn)生一個實例 ，確保該類的 唯一性 。

剩余60%，完整內(nèi)容請點擊下方鏈接查看：

阿里云開發(fā)者社區(qū)，千萬開發(fā)者的選擇。百萬精品技術(shù)內(nèi)容、千節(jié)免費系統(tǒng)課程、豐富的體驗場景、活躍的社群活動、行業(yè)專家分享交流，盡在：

關(guān)鍵詞：