C++：工厂模式

工厂模式属于创建型模式，大致可以分为三类：
  简单工厂模式
  工厂方法模式
  抽象工厂模式

一、简单工厂模式
  简单工厂模式的一个特点就是在工厂类中直接判断从而产生新的产品，如果需要修改产品，就需要修改工厂类，下面举个例子：

#include <iostream>
using namespace std;

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

class product_A:public product
{
    public:
        void show(void)
        {
            cout << "Product_A: 魂斗罗" << endl;
        }
};

class product_B:public product
{
    public:
        void show(void)
        {
            cout << "Product_B: QQ飞车" << endl;
        }
};

class factory
{
    public:
        product* creat(int i)
        {
            switch(i)
            {
                case 0:
                    return new product_A;
                    break;
                case 1:
                    return new product_B;
                    break;
                default:
                     break;
            }
        }
};

int main(void)
{
    factory* f = new factory();
    f->creat(0)->show();
    f->creat(1)->show();

    return 0;
}

[john@bogon C++]$ ./a.out
Product_A: 魂斗罗
Product_B: QQ飞车

  但是如果需要增加新的产品时，就需要修改工厂类。这就违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。

二、工厂方法模式
  工厂方法模式是指定义一个用于创建对象的接口，让子类决定实例化哪一个类，还是以上面的例子来解释：现在有A、B两种产品，那么就直接开两个工厂。工厂A负责生产A产品，工厂B负责生产B种产品。

#include <iostream>
using namespace std;

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

class product_A:public product
{
    public:
        void show(void)
        {
            cout << "Product_A: 魂斗罗" << endl;
        }
};

class product_B:public product
{
    public:
        void show(void)
        {
            cout << "Product_B: QQ飞车" << endl;
        }
};

class factory
{
    public:
        virtual product* creat() = 0;
};

class factory_A:factory
{
    public:
        product* creat()  { return new product_A; }
};

class factory_B:factory
{
    public:
        product* creat()  { return new product_B; }
};     

int main(void)
{
    factory_A* fa = new factory_A();
    fa->creat()->show();

    factory_B* fb = new factory_B();
    fb->creat()->show();

    return 0;
}       

[john@bogon C++]$ ./a.out 
Product_A: 魂斗罗
Product_B: QQ飞车

  工厂方法模式也有缺点，每增加一种产品，就需要增加一个对象的工厂。如果公司发展迅速，推出了很多新的产品，那么就要开设相应的新工厂

三、抽象工厂模式
  抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类，适用于产品种类结构多的场合，主要用于创建一组（有多个种类）相关的产品，为它们提供创建的接口。

#include <iostream>
using namespace std;

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

class product_A1:public product_A
{
    public:
    void show(void)
    {
        cout << "Product_A1: 魂斗罗" << endl;
    }
};

class product_A2:public product_A
{
    public:
    void show(void)
    {
        cout << "Product_A2: QQ飞车" << endl;
    }
};

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

class product_B1:public product_B
{
    public:
        void show(void)
        {
            cout << "Product_B1: 2K OL" << endl;
        }
};

class product_B2:public product_B
{
    public:
        void show(void)
        {
            cout << "Product_B2: 篮球大师" << endl;
        }
};

class factory
{
    public:
        virtual product_A* creat_A() = 0;
        virtual product_B* creat_B() = 0;
};

class factory1:factory
{
    public:
        product_A* creat_A(void)  { return new product_A1;  }
        product_B* creat_B(void)  { return new product_B1;  }
};

class factory2:factory
{
    public:
        product_A* creat_A(void)  { return new product_A2;  }
        product_B* creat_B(void)  { return new product_B2;  }
};

int main(void)
{
    factory1* f1 = new factory1();
    f1->creat_A()->show();
    f1->creat_B()->show();

    factory2* f2 = new factory2();
    f2->creat_A()->show();
    f2->creat_B()->show();

    return 0;
}

[john@bogon C++]$ ./a.out 
Product_A1: 魂斗罗
Product_B1: 2K OL
Product_A2: QQ飞车
Product_B2: 篮球大师