设计模式---创建型模式-CSDN博客

本文链接：https://blog.csdn.net/baijiwei/article/details/79119347

创建型模式是创建对象时，不再由我们直接实例化对象，而是根据特定场景，由程序来确定创建对象的方式。一些系统在创建对象时，需要动态地决定怎样创建对象，创建哪些对象，以及如何组合和表示这些对象。创建模式描述了怎样构造和封装这些动态的决定。包含类的创建模式和对象的创建模式。
创建型模式主要有：单例模式（Singleton)、工厂方法模式（Factory Method）、抽象工厂模式(Abstract Factory)、生成器模式(Builder)和原型模式(Prototype)。

单例模式（Singleton）

一个class只允许产生一个实例对象，通常的做法是定义一个static public的成员函数，以及一个static private的数据成员，外界通过该static 成员函数获得一个该class的object，但是，要确保无论调用多少次，只能产生一个该class的对象。

clas examClass {
public:
   static public examClass* Instance() {
       if (NULL == single_obj) {
            single_obj = new examClass ();
       }
       return single_obj;
   }

private:
   static examClass* single_obj;
}

上面的代码示例，能够实现单线程模式下的单例模式，但是在多线程环境下，如果有多个线程同时调用到Instance示例，并且此时single_obj是NULL，就有可能2个或者多个examClass对象被创建出来。解决的办法，可以用如下的示例代码来解决：

clas examClass {
public:
   static public examClass* Instance() {
       if (NULL == single_obj) {
            mlock.Lock()
            single_obj = new examClass ();
            mlock.Unlock()
       }
       return single_obj;
   }

private:
   static examClass* single_obj;
   static mutex mlock;
}

工厂方法模式（Factory Method）

工厂模式，就是我们在构建对象实例的时候，不需要直接去调用具体class的构造函数，而是直接调用一个方法，就可以根据参数的不同构建需要的class的对象。GoF提供的工厂模式的架构如下：

我们可以采用如下示例代码来实现：

class AbstractClass {
public:
   void run();
}
class AClass : public class AbstractClass  {
public:
   void run();
}

class BClass : public class AbstractClass {
public:
   void run();
}

class CClass : public class AbstractClass{
public:
   void run();
}

class Product {
public:
    AbstractClass* Creator(int type);
}

class ConcreateProduct : public class Product {
public:
    AbstractClass* Creator(int type) {
       switch (type) {
       case TYPE_A:
           return new AClass();
       case TYPE_B:
           return new BClass();
       case TYPE_C:
           return new CClass();
       default:
           break;
       }
       return NULL;
    }
}

抽象工厂模式(Abstract Factory)

抽象工厂模式给我的感觉是几个相关的工厂模式的组合，这些相关的工厂模式用来分别创建不同系列的类似的实例。GoF 给的抽象工厂模式的结构图如下：

抽象工厂

举一个比较简单的例子，假设一家公司生产电脑配件，并且她生产各种类型的电脑配件，苹果的，戴尔的等，这些公司的电脑的配件都是不一样的。我们可以定义一个AbstractComponentFactory，它定义AppleComponentFactory, DellComponentFactory, 然后定义AbstractComputor，以及AppleComputor， DellComputor。

class AbstractComponentFactory {
public:
   virtual Mouse* produceMouse();
   virtual Desk*  produceDesk();
   AbstractComponentFactory* getFactor(int type);
private:
   AbstractComponentFactory* factor;
}
class AppleComponentFactory: public class AbstractComponentFactory {
public:
   Mouse* produceMouse();
   Desk*  produceDesk();
}
class DellComponentFactory: public class AbstractComponentFactory {
public:
   Mouse* produceMouse();
   Desk*  produceDesk();
}

class AbstractComputor {
public:
   virtual public createMouse(int type);
   virtual public createDesk(int type);
private:
   AbstractComponentFactory* factory;
}

class AppleComputor : public class AbstractComputor  {
public:
   public Mouse* createMouse() {
       return factor->getAppleFactory()->produceMouse();
   }
   public Mouse* createDesk() {
       return factor->getAppleFactory()->produceDesk();
   }
 }    

 class DellComputor : public class AbstractComputor  {
public:
   public Mouse* createMouse() {
       return factor->getDellFactory()->produceMouse();
   }
   public Mouse* createDesk() {
       return factor->getDellFactory()->produceDesk();
   }
 }

建造模式(Builder)

builder模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。Builder模式是一步一步创建一个复杂的对象，它允许用户可以只通过指定复杂对象的类型和内容就可以构建它们，用户不知道内部的具体构建细节。Builder模式是非常类似抽象工厂模式，细微的区别大概只有在反复使用中才能体会到。
builder