Abstract Factory 抽象工厂模式

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

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

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

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

抽象工厂模式的优缺点：

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

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

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

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

 #include <iostream>
 #include <string>

 class AbstractProduct {
 public:
     virtual ~AbstractProduct() {}
     virtual void message() = ;
 };
 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() = ;
 };
 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() = ;
     virtual AbstractObject* CreateObject() = ;
     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
 请按任意键继续. . .