设计原则

单一职责原则

定义：单一职责原则[1]，所谓职责是指类变化的原因。如果一个类有多于一个的动机被改变，那么这个类就具有多于一个的职责。而单一职责原则就是指一个类或者模块应该有且只有一个改变的原因。

bad case ：IPhone类承担了协议管理（Dial、HangUp）、数据传送（Chat）。

good case：

里式替换原则

定义：里氏代换原则[2](Liskov Substitution Principle LSP)，任何基类可以出现的地方，子类一定可以出现。

bad case ：ToyGun继承了AbstractGun，但Solider在调用KillEnemy()时会报错（ToyGun无法KillEnemy），即ToyGun无法完全行使AbstractGun的职责。

good case： AbstractToy中将声音、形状都委托给AbstractGun处理。

如果子类不能完整地实现父类的方法，或者父类的某些方法在子类中已经发生“畸变”，则建议断开父子继承关系，采用依赖、聚集、组合等关系代替。

依赖倒置原则

定义：依赖倒置原则[3]（Dependence Inversion Principle）是程序要依赖于抽象接口，不要依赖于具体实现。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。

bad case： Driver强依赖于奔驰车。

good case：

接口隔离原则

定义：接口隔离原则[4]，客户端不应该依赖它不需要的接口。一个类对另一个类的依赖应该建立在最小的接口上。

bad case：星探寻找美女的类图，其中IpettyGirl过于庞大，容纳过多可变的因素。

good case：通过拆分接口，提高了灵活性、可维护性。

迪米特法则

定义：迪米特法则[5]（Law of Demeter）又叫作最少知识原则（The Least Knowledge Principle），一个类对于其他类知道的越少越好，就是说一个对象应当对其他对象有尽可能少的了解，只和朋友通信，不和陌生人说话。

bad case： Teacher要求GroupLeader清点女生的数量，这里Teacher不应该依赖于Gril。

good case：

开闭原则

定义：开闭原则[6]，在面向对象编程领域中，规定“软件中的对象（类，模块，函数等等）应该对于扩展是开放的，但是对于修改是封闭的”。

以一个书店售书类图为例，当在书店要增加一个打折操作时。

bad case：修改实现类，在IBook上增加一个方法GetOffPrice() good case：通过扩展实现变化，增加一个子类OffNovelBook

创建型模式

工厂方法

定义一个用于创建对象的接口 Product* CreateProduct() ，让子类决定实例化哪一个类。工厂方法模式让类的实例化延迟到子类中进行，从而避免了在父类中创建对象时出现类名称紧耦合的问题，同时提高了代码的可扩展性和可维护性。（工厂方法的好处就是解耦，当我们修改了具体的类，对调用方而言完全不用修改）

class Product {    // 抽象产品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();}

抽象工厂

为创建一组相关或相互依赖的对象提供一个接口，而且无须指定他们的具体类。（工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结构。抽象工厂模式主要用来实现生产一系列的产品。）

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;}

生成器/建造者

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。（建造者模式关注的是零件类型和装配工艺（顺序））

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;    }

原型

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。（原型模式实现的是一个Clone 接口，注意是接口，也就是基于多态的 Clone 虚函数。）

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;}