设计模式之二-工厂模式-CSDN博客

本文链接：https://blog.csdn.net/u013078356/article/details/76232270

工厂模式简介

面向对象编程中，为了提高内聚和松耦合，经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类实现，达到了多态的目的。这里很容易出现的一个问题就是多个子类继承自抽象基类，我们不得不在每次要用到子类的地方就编写诸如 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;
}