设计模式之二-工厂模式

工厂模式简介

  面向对象编程中，为了提高内聚和松耦合，经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类实现，达到了多态的目的。这里很容易出现的一个问题就是多个子类继承自抽象基类，我们不得不在每次要用到子类的地方就编写诸如 new ×××;的代码，这样就有两个问题： ①客户程序员必须知道实际子类的名称。 ②程序的扩展性和维护变得越来越困难。
  为了解决这一问题，可以设置一个工厂类，专门负责各个对象的实例化。 ①定义创建对象的接口，封装了对象的创建；②使得具体化类的工作延迟到了子类中。
  对于工厂模式，为了使其能更好的解决多种情况的问题，将其分为三类：简单工厂模式（Simple Factory），工厂方法模式（Factory Method），抽象工厂模式（Abstract Factory）
  本文参考文章：
   C++设计模式之工厂模式
   三种工厂模式的C++实现
   设计模式C++实现（1）——工厂模式

简单工厂模式

  简单工厂模式是属于创建型模式，又叫做静态工厂方法(static Factory Method)模式，简单工厂模式是由一个工厂对象决定创建出来哪一种产品类的实例.
  简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一类产品类(这些产品类继承自一个父类或接口)的实例。打个比方假设有一个工厂，他能生产出A、B两种产品。当客户需要产品的时候一定要告诉共产是哪种产品，是A还是B。

#include <iostream>//产品类enum PRODUCTTYPE {A, B};class Product{public:    virtual void show() = 0;};class ProductA : public Product{public:    void show()    {        std::cout << "Product_A" << std::endl;    }};class ProductB : public Product{public:    void show()    {        std::cout << "Product_B" << std::endl;    }};//工厂类class Factory{public:    Product* createProduct(PRODUCTTYPE type)    {        switch (type) {        case A:            return new ProductA();            break;        case B:            return new ProductB();            break;        default:            break;        }    }};int main(){    Factory *factory = new Factory();    factory->createProduct(A)->show();    factory->createProduct(B)->show();     delete factory;    return 0;}

  简单工厂的设计方法存在一个缺点，就是要增加新的核类型时，就需要修改工厂类。这就违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。

工厂方法模式

  所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。打个比方现在有A、B两种产品，那么久开两个工厂。工厂A负责生产A产品，工厂B负责生产B种产品。这时候客户不需要告诉共产生产哪种产品了，只需要告诉工厂生产就可以了。

#include <iostream>//产品类enum PRODUCTTYPE {A, B};class Product{public:    virtual void show() = 0;};class ProductA : public Product{public:    void show()    {        std::cout << "Product_A" << std::endl;    }};class ProductB : public Product{public:    void show()    {        std::cout << "Product_B" << std::endl;    }};//工厂类class Factory{public:    virtual Product* createProduct() = 0;};class FactoryA : public Factory{public:    Product* createProduct()    {        return new ProductA();    }};class FactoryB : public Factory{public:    Product* createProduct()    {        return new ProductB();    }}; int main(){    FactoryA *factory_a = new FactoryA();    FactoryB *factory_b = new FactoryB();    factory_a->createProduct()->show();    factory_b->createProduct()->show();    delete factory_a;    delete factory_b;    return 0;}

抽象工厂模式

  假如我们A产品中有A1和A2两种型号的厂品，B产品中有B1和B2两种型号的厂品，那怎么办，上面两种工厂模式就不能解决了。这个时候抽象工厂模式就登场了。还是开设两家工厂，工厂A负责生产A1 、A2型号产品，B工厂负责生产B1、B2型号的产品。
  提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 适用性：一个系统要独立于它的产品的创建、组合和表示时。一个系统要由多个产品系列中的一个来配置时。当你要强调一系列相关的产品对象的设计以便进行联合使用时。当你提供一个产品类库，而只想显示它们的接口而不是实现时。

#include <iostream>//产品类class Product1{public:    virtual void show() = 0;};class ProductA1 : public Product1{public:    void show()    {        std::cout << "Product_A1" << std::endl;    }};class ProductB1 : public Product1{public:    void show()    {        std::cout << "Product_B1" << std::endl;    }};class Product2{public:    virtual void show() = 0;};class ProductA2 : public Product2{public:    void show()    {        std::cout << "Product_A2" << std::endl;    }};class ProductB2 : public Product2{public:    void show()    {        std::cout << "Product_B2" << std::endl;    }};//工厂类class Factory{public:    virtual Product1* createProduct1() = 0;    virtual Product2* createProduct2() = 0;};class FactoryA : public Factory{public:    Product1* createProduct1(){ return new ProductA1(); }    Product2* createProduct2(){ return new ProductA2(); }};class FactoryB : public Factory{public:    Product1* createProduct1(){ return new ProductB1(); }    Product2* createProduct2(){ return new ProductB2(); }};int main(){    FactoryA *factory_a = new FactoryA();    factory_a->createProduct1()->show();    factory_a->createProduct2()->show();    FactoryB *factory_b = new FactoryB();    factory_b->createProduct1()->show();    factory_b->createProduct2()->show();    delete factory_a;    delete factory_b;    return 0;}