常见设计模式-工厂模式(C++)

1、简单工厂模式

简单工厂模式是属于创建型模式，又叫做静态工厂方法(static Factory Method)模式，简单工厂模式是由一个工厂对象决定创建出来哪一种产品类的实例.

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一类产品类(这些产品类继承自一个父类或接口)的实例。打个比方

假设有一个工厂，他能生产出A、B两种产品。当客户需要产品的时候一定要告诉共产是哪种产品，是A还是B。当新增加一种新产品的时候，那么就要去修改工厂的类。

class Product
{
public:
    virtual void show() = 0;
};

class ProductA : public Product
{
public:
    void show() { std::cout << "ProductA" << std::endl;}
};

class ProductB : public Product
{
public:
    void show() { std::cout << "ProductB" << std::endl;}
};

class Factory
{
public:
    Product * CreatePoduct(int type)
    {
        if(type == 1)
        {
            return new ProductA();
        }
        else if(type = 2)
        {
            return new ProductB();
        }
        else
        {
            return NULL;
        }
    }
};

int main()
{
    Factory factory;

    Product * a = factory.CreatePoduct(1);
    Product * b = factory.CreatePoduct(2);
    a->show();
    b->show();

    return 0;
}

2、工厂方法模式：

上面的简单工厂模式的缺点是当新增产品的时候就要去修改工厂的类，这就违反了开放封闭原则，(类、模块、函数)可以扩展，但是不可以修改，于是，就出现了工厂方法模式。所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。打个比方

现在有A、B两种产品，那么久开两个工厂。工厂A负责生产A产品，工厂B负责生产B种产品。这时候客户不需要告诉共产生产哪种产品了，只需要告诉共产生产就可以了。

class Product
{
public:
    virtual void show() = 0;
};

class ProductA : public Product
{
public:
    void show() { std::cout << "ProductA" << std::endl;}
};

class ProductB : public Product
{
public:
    void show() { std::cout << "ProductB" << 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()
{
    Factory * factoryA = new FactoryA();

    factoryA->CreateProduct()->show();

    Factory * factoryB = new FactoryB();

    factoryB->CreateProduct()->show();

    return 0;
}

3、抽象工厂模式

为什么要有抽象工厂模式，假如我们A产品中有A1和A2两种型号的厂品，B产品中有B1和B2两种型号的厂品，那怎么办，上面两种工厂模式就不能解决了。这个时候抽象工厂模式就登场了。还是开设两家工厂，工厂A负责生产A1 、A2型号产品，B工厂负责生产B1、B2型号的产品。

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

class Product1
{
public:
    virtual void show() = 0;
};

class ProductA1 : public Product1
{
public:
    void show() {std::cout<<"ProductA1"<<std::endl;};
};

class ProductB1 : public Product1
{
public:
    void show() {std::cout<<"ProductB1"<<std::endl;}
};

class Product2
{
public:
    virtual void show() = 0;
};

class ProductA2 : public Product2
{
public:
    void show() {std::cout<<"ProductA2"<<std::endl;};
};

class ProductB2 : public Product2
{
public:
    void show() {std::cout<<"ProductB2"<<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()
{
    Factory * a = new FactoryA();
    a->CreateProduct1()->show();
    a->CreateProduct2()->show();

    Factory * b = new FactoryB();
    b->CreateProduct1()->show();
    b->CreateProduct2()->show();

    return 0;
}