C++设计模式03——抽象工厂模式

What（是什么：定义）

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

Why（为什么要使用：效果是什么）

主要解决接口选择的问题

1、它分离了具体的类 Abstract Factory模式帮助你控制一个应用创建的对象的类。因为一个工厂封装创建产品对象的责任和过程，它将客户与类的实现分离。客户通过它们的抽象接口操纵实例。产品的类名也在具体工厂的实现中被分离；它们不出现在客户代码中。

2、它使得易于交换的产品系列 一个具体工厂类在一个应用中仅出现一次————即在它初始化的时候。这使得改变一个应用的具体工厂变得很容易。它只需改变具体的工厂即可使用不同的产品配置，这是因为一个抽象工厂创建了一个完整的产品系列，所以整个产品系列会立刻改变。

3、它有利于产品的一致性 当一个系列中的产品对象被设计成一起工作时，一个应用一次只能使用同一个系列中的对象，这一点很重要。而AbstractFactory很容易实现这一点。

4、难以支持新种类的产品 难以扩展抽象工厂以生产新种类的产品。这是因为AbstractFactory接口确定了可以被创建的产品集合。支持新种类的产品就需要扩展该工厂接口，这将涉AbstractFactory类及其所有子类的改变。

Who（变化的是谁：可变的方面）

产品对象家簇

When（什么情况下使用：适用性）

在以下情况可以使用AbstractFactory模式

一个系统要独立于它的产品的创建、组合和表示时。

一个系统要由多个产品系列中的一个 来配置时。

当你要强调一系列相关的产品对象的设计以例进行联合使用时。

当你提供一个产品类库，而只想显示它们的接口而不是实现时。

Where：抽象工厂模式的结构在哪里

UML图如下：

How：如何实现

代码实现

#include <iostream>

using namespace std;

class AbstractProductCPU
{
public:
    virtual void show() = 0;
    virtual ~AbstractProductCPU()
    {
        cout << "AbstractProductCPU destructor========this=" << this << endl;
    }
};

class iPhoneProductCPU: public AbstractProductCPU
{
public:
    void show()
    {
        cout << "I'm iPhoneProductCPU================this=" << this << endl;
    }
    ~iPhoneProductCPU()
    {
        cout << "iPhoneProductCPU destructor==========this=" << this << endl;
    }
};

class iMacProductCPU: public AbstractProductCPU
{
public:
    void show()
    {
        cout << "I'm iMacProductCPU=============this=" << this << endl;
    }

    ~iMacProductCPU()
    {
        cout << "iMacProductCPU destructor=======this=" << this << endl;
    }
};

class AbstractProductScreen
{
public:
    virtual void show() = 0;
    virtual ~AbstractProductScreen()
    {
        cout << "AbstractProductScreen destructor=====this=" << this << endl;
    }
};

class iPhoneProductScreen: public AbstractProductScreen
{
public:
    void show()
    {
        cout << "I'm iPhoneProductScreen=============this=" << this << endl;
    }
    ~iPhoneProductScreen()
    {
        cout << "iPhoneProductScreen destructor=======this=" << this << endl;
    }
};

class iMacProductScreen: public AbstractProductScreen
{
public:
    void show()
    {
        cout << "I'm iMacProductScreen=============this=" << this << endl;
    }

    ~iMacProductScreen()
    {
        cout << "iMacProductScreen destructor=======this=" << this << endl;
    }
};

class AbstractFactory
{
public:
    virtual AbstractProductCPU* createCUPFactory() = 0;
    virtual AbstractProductScreen* createScreenFactory() = 0;
    virtual ~AbstractFactory()
    {
        cout << "AbstractFactory destructor===========this=" << this << endl;
    }
};

class iPhoneFactory: public AbstractFactory
{
public:
    AbstractProductCPU* createCUPFactory()
    {
        return new iPhoneProductCPU();
    }
    AbstractProductScreen* createScreenFactory()
    {
        return new iPhoneProductScreen();
    }
    ~iPhoneFactory()
    {
        cout << "iPhoneFactory destructor=============this=" << this << endl;
    }
};

class iMacFactory: public AbstractFactory
{
public:
    AbstractProductCPU* createCUPFactory()
    {
        return new iMacProductCPU();
    }
    AbstractProductScreen* createScreenFactory()
    {
        return new iMacProductScreen();
    }
    ~iMacFactory()
    {
        cout << "iMacFactory destructor=======this=" << this << endl;
    }
};

int main()
{
    //iPhone工厂
    unique_ptr<AbstractFactory> iPhonefactory(new iPhoneFactory());
    unique_ptr<AbstractProductCPU> iPhoneCPU(iPhonefactory->createCUPFactory());
    unique_ptr<AbstractProductScreen> iPhoneScreen(iPhonefactory->createScreenFactory());
    iPhoneCPU->show();
    iPhoneScreen->show();
    cout << endl;
    //iMac工厂
    unique_ptr<AbstractFactory> iMacfactory(new iPhoneFactory());
    unique_ptr<AbstractProductCPU> iMacCPU(iMacfactory->createCUPFactory());
    unique_ptr<AbstractProductScreen> iMacScreen(iMacfactory->createScreenFactory());
    iMacCPU->show();
    iMacScreen->show();
    cout << "Hello World!" << endl << endl;
    return 0;
}

总结：

1、它分离了具体的类 Abstract Factory模式帮助你控制一个应用创建的对象的类。因为一个工厂封装创建产品对象的责任和过程，它将客户与类的实现分离。客户通过它们的抽象接口操纵实例。产品的类名也在具体工厂的实现中被分离；它们不出现在客户代码中。

2、它使得易于交换产品系列 一个具体工厂类在一个应用中仅出现一次——即在它初始化的时候。这使得改变一个应用的具体工厂变得很容易。它只需改变具体的工厂即可使用不同的产品配置，这是因为一个抽象工厂创建一个完整的产品系列，所以整个产品系列会立刻改变。

3、它有利于产品的一致性 当一个系列中的产品对象被设计成一起工作时，一个应用一次只能使用同一个系列中的对象，这一点很重要而AbstractFactory很容易实现这一点。

4、难以支持新种类的产品 难以扩展抽象工厂以生产新种类的产品。这是因为AbstractFactory接口确定了可以被创建的产品集合，支持新种类的产品就需要扩展该工厂接口，这将涉及AbstractFactory类及其所有子类的改变。

参考：

http://www.cnblogs.com/jiese/p/3156753.html

https://blog.csdn.net/CoderAldrich/article/details/83114687

update:2021-08-23