設計模式——創建型設計模式總結（簡單工廠、普通工廠、抽象工廠、建造者、原型和單例）

創建型設計模式總結

（轉載請注明來源 http://www.cnblogs.com/jerry19880126/）

創建型設計模式包括簡單工廠模式，普通工廠模式，抽象工廠模式，建造者模式，原型模式和最簡單的單例模式。

 

簡單工廠模式（Simple Factory）

 

從UML圖中可以看出，工廠是具體的，Product是抽象的，里面的方法Operation是virtual的，它的三個子類是具體的，子類中的Operation覆蓋父類的方法Operation，由多態知識可知，運行時將會調用子類的Operation，父類的Operation只是聲明的“接口”。

多態有三個條件：一是父類的virtual，二是子類的覆蓋（要求函數名、參數、返回值都要一模一樣），三是父類的指針或引用指向子類的對象。前兩個條件已經滿足，下面關鍵是討論第三個條件。

第三個條件的關鍵就是Factory了，Factory能根據客戶端的請求，生成不同的具體對象，這可以用flag來標識，假定flag = 1時，生成ConcreteProduct1對象；flag = 2時，生成ConcreteProduct2對象。因此，可以在Factory這樣寫CreateProduct()。

Product* CreateProduct(flag)

{

Switch(flag)

case 1: return new ConcreateProduct1(); break;

case 2: return new ConcreateProduct2(); break;

case 3:…

}

 

在客戶端只要用

Factory f; // 生成factory對象

f.getProduct(1).Operation();就可以調用ConcreteProduct1的方法了

f.getProduct(2).Operation();就可以調用ConcreteProudct2的方法了。

 

這樣說來，相信讀者已經明白，其實工廠方法就是根據客戶端不同的“要求”，產生不同的具體對象，再利用多態特性，調用相應具體對象的方法。

 

下面給出可執行的源代碼，與上述例子不盡相同，但思想是一樣的，運行結果如下圖所示。

#include <iostream>
using namespace std;

// 簡單工廠模式

// 抽象產品
class AbstractProduct
{
public:
    virtual void getProductsName() = 0;
};

// 具體產品1
class ConcreteProduct1: public AbstractProduct
{
public:
    void  getProductsName()
    {
        cout << "ConcreteProduct1" << endl;
    }
};


// 具體產品2
class ConcreteProduct2: public AbstractProduct
{
public:
    void  getProductsName()
    {
        cout << "ConcreteProduct2" << endl;
    }
};


// 具體的工廠（沒有抽象工廠）
class ConcreteFactory
{
public:
    AbstractProduct* getProductObject(int flag)
    {
        if(flag == 1)
        {
            return new ConcreteProduct1();
        }
        else if(flag == 2)
        {
            return new ConcreteProduct2();
        }
        else
        {
            return 0;
        }
    }
};

int main()
{
    ConcreteFactory f;
    AbstractProduct* p1 = f.getProductObject(1);
    AbstractProduct* p2 = f.getProductObject(2);
    p1->getProductsName();
    p2->getProductsName();
    delete p1;
    delete p2;
    return 0;
}

 

運行結果如下：

 

（普通）工廠模式（Factory）

與簡單工廠模式換湯不換葯，只是把工廠也“抽象”了，UML圖如下所示：

 

從上圖可以看出，只不過多出一塊抽象工廠而已。抽象工廠提供CreateProduct的虛接口，在ConcreteFactory中實現，為了便於說明問題，這里假定有兩個ConcreteFactory，一個是ConcreteFactory1，只生產ConcreteProduct1產品，另一個是ConcreteFactory2，只生產ConcreteProduct2產品。

 

以ConcreteFactory1為例，代碼框架如下：

class ConcreateFactory1: public Factory

{

 Product* CreateProduct()

{

     return new ConcreteProduct1();

}

};

 

在客戶端用 Factory *f = new ConcreteFactory1(); f->CreateProduct();就可以得到ConcreteProduct1的對象了。

 

下面給出可執行的源代碼，運行結果的截圖放在后面。

#include <iostream>
using namespace std;

//普通工廠模式

//抽象產品
class AbstractProduct
{
public:
    virtual void getProductName() = 0;
};

//具體產品1
class ConcreteProduct1: public AbstractProduct
{
public:
    void getProductName()
    {
        cout << "ConcreteProduct1" << endl;
    }
};

//具體產品2
class ConcreteProduct2: public AbstractProduct
{
public:
    void getProductName()
    {
        cout << "ConcreteProduct2" << endl;
    }
};


//抽象工廠
class AbstractFactory
{
public:
    virtual AbstractProduct* getProduct() = 0;
};

//具體工廠1
class ConcreteFactory1: public AbstractFactory
{
public:
    AbstractProduct* getProduct()
    {
        return new ConcreteProduct1();
    }
};


//具體工廠2
class ConcreteFactory2: public AbstractFactory
{
public:
    AbstractProduct* getProduct()
    {
        return new ConcreteProduct2();
    }
};

int main()
{
    AbstractFactory* f1 = new ConcreteFactory1();
    AbstractFactory* f2 = new ConcreteFactory2();
    f1->getProduct()->getProductName();
    f2->getProduct()->getProductName();
    delete f1, f2;
    return 0;
}

 

運行結果如下：

 

抽象工廠模式（Abstract Factory）

 

抽象工廠又是（普通）工廠模式的升級版，但本質是相同的。觀察UML圖，可以看到不同的地方在於多了一個抽象產品的類。

ConcreateFactory1只生產ProductA1和ProductB1，即下標帶“1”的產品。可以預見，在ConcreteFactory1中的兩個方法應該如下：

 

AbstractProductA* CreateProductA()

{

         return new ProductA1();

}

AbstractProductB* CreateProductB()

{

         return new ProductB1();

}

 

ConcreateFactory2中的兩個方法類似，只是將最后的下標換成2而已。

 

下面給出可以執行的源代碼，運行截圖放在代碼的后面。

#include <iostream>

using namespace std;

 

// 抽象工廠模式

 

// 抽象產品A

class AbstractProductA

{

public:

         virtual void getProductName() = 0;

};

 

// 具體產品A1

class ConcreteProductA1: public AbstractProductA

{

public:

         void getProductName()

         {

                   cout << "ConcreteProductA1" << endl;

         }

};

 

 

// 具體產品A2

class ConcreteProductA2: public AbstractProductA

{

public:

         void getProductName()

         {

                   cout << "ConcreteProductA2" << endl;

         }

};

 

 

// 抽象產品B

class AbstractProductB

{

public:

         virtual void getProductName() = 0;

};

 

// 具體產品B1

class ConcreteProductB1: public AbstractProductB

{

public:

         void getProductName()

         {

                   cout << "ConcreteProductB1" << endl;

         }

};

 

 

// 具體產品B2

class ConcreteProductB2: public AbstractProductB

{

public:

         void getProductName()

         {

                   cout << "ConcreteProductB2" << endl;

         }

};

 

 

// 抽象工廠

class AbstractFactory

{

public:

         virtual AbstractProductA* getProductA() = 0;

         virtual AbstractProductB* getProductB() = 0;

};

 

 

// 具體工廠1

class ConcreteFactory1: public AbstractFactory

{

         AbstractProductA* getProductA()

         {

                   return new ConcreteProductA1;

         }

         AbstractProductB* getProductB()

         {

                   return new ConcreteProductB1;

         }

};

 

// 具體工廠2

class ConcreteFactory2: public AbstractFactory

{

         AbstractProductA* getProductA()

         {

                   return new ConcreteProductA2;

         }

 

         AbstractProductB* getProductB()

         {

                   return new ConcreteProductB2;

         }

};

 

 

int main()

{

         AbstractFactory *f1 = new ConcreteFactory1();

         AbstractFactory *f2 = new ConcreteFactory2();

         f1->getProductA()->getProductName();

         f1->getProductB()->getProductName();

         f2->getProductA()->getProductName();

         f2->getProductB()->getProductName();

         delete f1, f2;

         return 0;

}

 

運行結果如下：

 

“工廠系列”設計模式總結

下面總結一下“工廠系列”設計模式，簡單工廠模式只有一份抽象的產品，工廠是具體的；（普通）工廠模式的同樣也只有一份抽象的產品，但工廠有抽象的了；抽象工廠模式工廠當然是抽象的，但是它獨特的地方在於產品至少有兩份是抽象的。

 

建造者模式（Builder）

 

建造者模式包含一個抽象的Builder類，還有它的若干子類——ConcreteBuilder，不用理會UML圖上的Product，關鍵是看Director，Director里面的方法Construct()其實包含了Builder指針或引用的形參，由客戶端傳入某個ConcreateBuilder對象。Construct(Builder* builder)的方法大致如下：

Construct(Builder* builder)

{

         Builder->BuildPartA();

         Builder->BuildPartB();

         …

}

由多態性可知，客戶端傳進來的ConcreteBuilder是誰，就調用誰的方法。

 

可執行的源代碼如下，運行結果在源代碼的后面。

#include <iostream>

using namespace std;

 

// 建造者模式

 

// 抽象建造者

class AbstractBuilder

{

public:

         virtual void buildPart1() = 0;

         virtual void buildPart2() = 0;

};

 

 

//具體建造者1

class ConcreteBuilder1: public AbstractBuilder

{

public:

         void buildPart1()

         {

                   cout << "用A構造第一部分" << endl;

         }

         void buildPart2()

         {

                   cout << "用B構造第二部分" << endl;

         }

};

 

 

//具體建造者2

class ConcreteBuilder2: public AbstractBuilder

{

public:

         void buildPart1()

         {

                   cout << "用X構造第一部分" << endl;

         }

         void buildPart2()

         {

                   cout << "用Y構造第二部分" << endl;

         }

};

 

// 指揮者，注意其方法的參數是抽象建造者的指針

class Director

{

public:

         void build(AbstractBuilder *builder)

         {

                   builder->buildPart1();

                   builder->buildPart2();

         }

};

 

int main()

{

         Director d;

         d.build(new ConcreteBuilder1());

         d.build(new ConcreteBuilder2());

         return 0;

}

 

運行結果如下：

 

原型模式（Prototype）

 

聽起來挺玄乎，其實說穿了，就是深拷貝問題。當一個類中包含了指針，那么這個類一定要顯示規定三個東西：拷貝構造函數，重載”=”操作符以及析構函數。如果程序員使用編譯器默認產生的這三個函數，那么得到的對象是原來對象的“淺拷貝”，即只是簡單拷貝了指針的值（只復制了地址），沒有復制指針指向空間的內容。“淺拷貝”只會保留最近的修改結果，而且在析構時容易出現重復析構的錯誤。

“深拷貝”是相對淺拷貝的概念說的，深拷貝不是簡單的拷貝指針的值（地址），而是重新生成了一個新的空間，這個空間里存放的內容與傳入類內容是完全相同的。

 

請看下面“淺拷貝”的實例：

 

#include <iostream>

using namespace std;

 

// 原型模式，本質就是深拷貝

 

// 淺拷貝，這時可以觀察到p的地址是一樣的，析構的時候因為重復釋放同一地址空間，所以

// 會出錯。

class PrototypeWrong

{

private:

         int a;

         int *p; // 有一個指針

public:

         PrototypeWrong()

         {

                   a = 3;

                   p = new int(2);

         }

         void outputPointerAddress()

         {

                   cout << p << endl;

         }

 

         ~PrototypeWrong()

         {

                   delete p;

         }

};

 

int main()

{

         // 這一部分是錯誤的原型模式的測試樣例

         PrototypeWrong p1;

         PrototypeWrong p2 = p1;

         p1.outputPointerAddress();

         p2.outputPointerAddress();

}

 

運行結果為：

 

可以看到指針值（地址）是相同的，所以是淺拷貝，程序沒有出現“請按任意鍵繼續”的提示，說明程序其實是卡死的，原因是重復析構指針p。

 

再看看“深拷貝”的實例：

#include <iostream>

using namespace std;

 

// 原型模式，本質就是深拷貝

 

// 深拷貝，正確的原型模式

class PrototypeRight

{

private:

         int a;

         int *p; // 有一個指針

public:

         PrototypeRight()

         {

                   a = 3;

                   p = new int(2);

         }

 

         // 不使用默認的拷貝構造函數！

         PrototypeRight(const PrototypeRight& obj)

         {

                   a = obj.a;

                   p = new int(*obj.p);

         }

 

         void outputPointerAddress()

         {

                   cout << p << endl;

         }

 

         ~PrototypeRight()

         {

                   delete p;

         }

};

 

int main()

{

         // 這一部分是正確的原型模式的測試樣例

        

         PrototypeRight p1;

         PrototypeRight p2 = p1;

         p1.outputPointerAddress();

         p2.outputPointerAddress();

         return 0;

        

}

 

運行結果如下：

 

可見指針值不同了，說明指向了不同的空間，而且成功顯示了“請按任意鍵繼續”的提示符，說明析構也是正常了。但這里的程序還不完整，按照C++的程序風格，還應該重載“=”運算符，這里的練習便留給讀者。

 

單例模式（Singleton）

顧名思義，就是保證某個類只有一個實例（對象），這個應用還是很廣的，假設騰迅想讓用戶每次只能用一個QQ登陸，就可以用到這個模式。

 

這個UML圖非常簡單，可以說也是所有設計模式中最簡單的了，所以在面試中，常常被面試官們問起。

要使一個類只能生成一個對象，就是要限制使用它的構造函數，即將構造函數定義為private或protected的，然后另辟一個公有方法Instance，在這個方法里檢查instance（instance是指向本類的一個指針或引用，這在C++語法中是可以的）是否為空指針，若為空指針，則說明是第一次生成對象，那么操作是允許的，instance = new Singleton()，若指針非空，說明在之前已經有一個對象（實例）了，單例模式不允許再次生成實例，因此直接返回之前生成的對象的地址。

將instance定義成static變量，就更符合“單例”模式了，因為static變量只有一份，它屬於這個類，不屬於某個對象。相應的Instance()方法應該也定義成static的，用Singleton::Instance()來調用。注意這里的static方法和變量是必須的，如果函數不是static，則要事先生成對象才能調用Instance，就破壞了“單例”的思想了，如果變量不是static，那么靜態函數Instance又不能引用非static變量。

 

下面給出可以執行的源程序：

#include <iostream>

using namespace std;

 

// 單例模式

class Singleton

{

private:

         Singleton(){}; // 不允許直接構造其對象

         static Singleton *instance;

 

public:

         static Singleton* createInstance()

         {

                   if(!instance)

                   {

                            // 對象第一次被創建，允許

                            cout << "創建新對象" << endl;

                            instance = new Singleton();

                   }

                   else

                   {

                            // 請求再次創建對象，不允許

                            cout << "已經創建過對象了，返回原對象" << endl;

                   }

                   return instance;

         }

         void getAddress()

         {

                   cout << "我的地址是 " << instance << endl;

         }

};

 

Singleton* Singleton::instance = 0; //在初始化的時候，不能在前面加static了

 

int main()

{

         //Singleton s;//報錯：無法訪問 private 成員(在“Singleton”類中聲明)

         Singleton *s1 = Singleton::createInstance();

         s1->getAddress();

 

         cout << endl << endl;

 

         Singleton *s2 = Singleton::createInstance();

         s2->getAddress();

         return 0;

}

 

運行結果為：