Abstract Factory 抽象工厂模式

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

抽象工厂顾名思义就是对工厂的抽象，它提供了一组创建抽象产品对象的操作接口，我们实际使用的是抽象工厂的派生类，派生类中提供了操作的具体实现，创建一组具体的对象。

以下情况可以使用抽象工厂模式：

• 一个系统要独立于它的产品的创建、组合和表示时。
• 一个系统要由多个产品系列中的一个来配置时。
• 当你要强调一系列相关的产品对象的设计以便进行联合使用时。
• 当你提供一个产品类库，而只想显示它们的接口而不是实现时。

抽象工厂模式的优缺点：

• 他分离了具体的类
• 它使得易于交换产品系列
• 它有利于产品的一致性
• 难以支持新种类的产品

在实现时最好将工厂作为单件。

如果有多个可能的产品系列，具体工厂也可以使用Prototype原型模式来实现。具体工厂使用产品系列中每一个产品的实例来初始化，且通过复制它的原型来创建新的产品。在基于原型的方法中，使得不是每个新的产品系列都需要一个新的具体工厂类。

定义可扩展的工厂。比如用参数指定将被创建的对象的种类。注意所有的产品都将返回相同类型的抽象接口给用户，可以用dynamic_cast进行类型转换，但是也有可能失败。

#include <iostream>
#include <string>

class AbstractProduct {
public:
    virtual ~AbstractProduct() {}
    virtual void message() = 0;
};
class Product : public AbstractProduct {
    virtual ~Product() {}
    virtual void message() {
        std::cout << "我是一个普通的Product" << std::endl;
    }
};
class ProductEx : public AbstractProduct {
    virtual ~ProductEx() {}
    virtual void message() {
        std::cout << "我是加强后的Product" << std::endl;
    }
};

class AbstractObject {
public:
    virtual ~AbstractObject() {}
    virtual void gao() = 0;
};
class Object : public AbstractObject {
    virtual ~Object() {}
    virtual void gao() {
        std::cout << "虽然叫做Object，但是只是一个普通的Object" << std::endl;
    }
};
class ObjectEx : public AbstractObject {
    virtual ~ObjectEx() {}
    virtual void gao() {
        std::cout << "虽然叫做ObjectEx好像很厉害的样子，其实还是一个普通的Object" << std::endl;
    }
};

class AbstractFactory {
public:
    virtual AbstractProduct* CreateProduct() = 0;
    virtual AbstractObject* CreateObject() = 0;
    virtual ~AbstractFactory() {}
protected:
    AbstractFactory(){}
    AbstractFactory(const AbstractFactory&);
    AbstractFactory& operator=(const AbstractFactory&);
};

class ConcreteFactory : public AbstractFactory {
public:
    virtual AbstractProduct* CreateProduct() {
        return new Product();
    }
    virtual AbstractObject* CreateObject() {
        return new Object();
    }
    static ConcreteFactory* Instance() {
        static ConcreteFactory _instance;
        return &_instance;
    }
};

class ExtraFactory : public AbstractFactory {
public:
    virtual AbstractProduct* CreateProduct() {
        return new ProductEx();
    }
    virtual AbstractObject* CreateObject() {
        return new ObjectEx();
    }
    static ExtraFactory* Instance() {
        static ExtraFactory _instance;
        return &_instance;
    }
};

测试代码

#include <iostream>
#include "Abstract_Factory.h"

using namespace std;

int main()
{
    auto fac = ConcreteFactory::Instance();
    auto pro = fac->CreateProduct();
    auto obj = fac->CreateObject();
    pro->message();
    obj->gao();

    auto facEx = ExtraFactory::Instance();
    auto proEx = facEx->CreateProduct();
    auto objEx = facEx->CreateObject();
    proEx->message();
    objEx->gao();

    system("pause");
}

测试结果

我是一个普通的Product
虽然叫做Object，但是只是一个普通的Object
我是加强后的Product
虽然叫做ObjectEx好像很厉害的样子，其实还是一个普通的Object
请按任意键继续. . .