C++设计模式1——工厂模式

       创建对象的类是工厂，创建的对象就是产品，使用工厂生产产品，只需用工厂提供的接口生产产品即可，不用关心具体的生产过程。

       工厂模式分为三种：①简单工厂模式  ②工厂方法模式  ③抽象工厂模式

       三种模式越来越抽象，适用于不同的场景，先用类图介绍下三种模式：

①简单工厂模式：一个工厂生产多种产品。

②工厂方法模式：多个工厂，每个工厂只能生产一种产品。工厂、产品都是抽象类，用子类工厂生产。

③抽象工厂模式：多个工厂，每个工厂可以生产多种产品。工厂、产品都是抽象类，用子类工厂生产，每个子类工厂可以生产多种产品，形成多产品的组合。

       工厂方法模式和抽象工厂模式的区别：工厂方法模式适用于产品种类结构单一的场合，为一类产品提供创建的接口；而抽象工厂方法适用于产品种类结构多的场合，主要用于创建一组（有多个种类）相关的产品，为它们提供创建的接口；就是当具有多个抽象角色时，抽象工厂便可以派上用场。

 

代码实现：

factory.h:

#ifndef FACTORY_H
#define FACTORY_H

using std::cout;
using std::endl;

enum PRODUCT_TYPE
{
    PRO_A = 1,
    PRO_B,
};


//1、简单工厂模式
class Product
{
public:
    virtual void show() = 0;
};

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

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


class Factory
{
public:
    Product * CreateProduct(PRODUCT_TYPE type)
    {
        switch (type)
        {
        case PRO_A:
            return new ProductA;
            break;
        case PRO_B:
            return new ProductB;
            break;
        default:
            return NULL;
            break;
        }
    }
};


#endif


//2、工厂方法模式
class Product2
{
public:
    virtual void show() = 0;
};

class Product2A : public Product2
{
    void show()
    {
        cout << "This is Product2A" << endl;
    }
};

class Product2B : public Product2
{
    void show()
    {
        cout << "This is Product2B" << endl;
    }
};

class Factory2
{
public:
    virtual Product2 * CreateProduct2() = 0;
};

class Factory2A : public Factory2
{
public:
    Product2 * CreateProduct2()
    {
        cout << "Factory2A create Product 2A" << endl;
        return new Product2A();
    }
};

class Factory2B : public Factory2
{
public:
    Product2 * CreateProduct2()
    {
        cout << "Factory2B create Product 2B" << endl;
        return new Product2B();
    }
};


//3、抽象工厂模式
class Product3
{
public:
    virtual void show() = 0;
};

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

class Product3A : public Product3
{
public:
    void show()
    {
        cout << "This is Product3A" << endl;
    }
};

class Product3B : public Product3
{
public:
    void show()
    {
        cout << "This is Product3B" << endl;
    }
};

class Product4A : public Product4
{
public:
    void show()
    {
        cout << "This is Product4A" << endl;
    }
};

class Product4B : public Product4
{
public:
    void show()
    {
        cout << "This is Product4B" << endl;
    }
};

class Factory3
{
public:
    virtual Product3* CreateProduct3() = 0;
    virtual Product4* CreateProduct4() = 0;
};

class Factory3A : public Factory3
{
public:
    Product3* CreateProduct3()
    {
        cout << "FactoryA create Product 3A" << endl;
        return new Product3A();
    }

    Product4* CreateProduct4()
    {
        cout << "FactoryA create Product 4A" << endl;
        return new Product4A();
    }

};

class Factory3B : public Factory3
{
public:
    Product3* CreateProduct3()
    {
        cout << "FactoryB create Product 3B" << endl;
        return new Product3B();
    }

    Product4* CreateProduct4()
    {
        cout << "FactoryB create Product 4B" << endl;
        return new Product4B();
    }

};

 

main.cpp:

#include <iostream>
#include <string>
#include "factory.h"

int main(void)
{
    //1、简单工厂模式
    //      在工厂中生产多个类型的产品
    //      该工厂可以生产多种产品；产品是抽象类
    cout << "1、简单工厂模式：" << endl;
    Factory * factory = new Factory();
    Product * pro_a = factory->CreateProduct(PRO_A);
    Product * pro_b = factory->CreateProduct(PRO_B);
    
    pro_a->show();
    pro_b->show();

    delete pro_a;
    delete pro_b;
    delete factory;
    

    //2、工厂方法模式
    //      用多个类型的子类工厂中生产多个类型的产品
    //      每个子类工厂只能生产一种产品，不同的子类工厂生产不同的产品；工厂、产品均是抽象类
    cout << "\n2、工厂方法模式：" << endl;
    Factory2A * fac_2a = new Factory2A();
    Product2 * pro_2a = fac_2a->CreateProduct2();
    pro_2a->show();

    Factory2B * fac_2b = new Factory2B();
    Product2 * pro_2b = fac_2b->CreateProduct2();
    pro_2b->show();

    delete fac_2a;
    delete pro_2a;
    delete fac_2b;
    delete pro_2b;


    //3、抽象工厂模式
    //      在多个类型的子类工厂中生产多个类型的产品
    //      每个子类工厂可以生产多种产品，形成多产品的组合；工厂、产品均是抽象类
    cout << "\n3、抽象工厂模式：" << endl;
    Factory3A * fac_3a = new Factory3A;
    Product3 * pro_3a = fac_3a->CreateProduct3();
    pro_3a->show();
    Product4 * pro_4a = fac_3a->CreateProduct4();
    pro_4a->show();

    Factory3B * fac_3b = new Factory3B;
    Product3 * pro_3b = fac_3b->CreateProduct3();
    pro_3b->show();
    Product4 * pro_4b = fac_3b->CreateProduct4();
    pro_4b->show();

    delete fac_3a;
    delete fac_3b;
    delete pro_3a;
    delete pro_4a;
    delete pro_3b;
    delete pro_4b;

    return 0;
}