工厂方法模式(Product)C++实现

意图：定义一个用于创建对象的接口，让子类觉定实例化哪一个类。

适用性：1.一个类不知道它必须创建的对象的时候。

　　　　2.一个类希望由它的子类指定它所创建的对象的时候。

　　　　3.当类将创建对象的职责委托给多个帮助子类中的某一个，并且希望将那一个帮助子类是代理者这一信息局部化的时候。

效果：   1.提供对象的扩展版本。

　　　　2.连接平行的类层次。

今天学工厂方法模式，感觉得从几个工厂模式一起去理解，所以我整体的讲一下自己的想法。

开始，老板要求按客户意愿产生对应产品。于是有简单工厂，代码如下：

#ifndef _PRODUCT_
#define _PRODUCT_
#include <string>
using namespace std;

class AbsProduct{
public:
    AbsProduct(){}
    virtual string GetProduct() = 0;
};

class Product_A:public AbsProduct{
public:
    Product_A(){}
    virtual string GetProduct(){return "Product_A";}
};

class Product_B:public AbsProduct{
public:
    Product_B(){}
    virtual string GetProduct(){return "Product_B";}
};

class Product_C:public AbsProduct{
public:
    Product_C(){}
    virtual string GetProduct(){return "Product_C";}
};

#endif

工厂部分代码：

#ifndef _FACTORY_
#define _FACTORY_
#include "Product.h"

class Factory{
public:
    Factory(){}
    AbsProduct* MakeProduct(char ch)
    {
        switch (ch)
        {
        case 'A':
            return new Product_A;
            break;
        case 'B':
            return new Product_B;
            break;
        case 'C':
            return new Product_C;
            break;
        default:
            break;
        }
    }
};

#endif

实现部分：

#include <iostream>
#include <string>
using namespace std;
#include "Factory.h"
#include "Product.h"

int main()
{
    Factory factory;
    AbsProduct* product = factory.MakeProduct('A');
    cout<<product->GetProduct()<<endl;

    product = factory.MakeProduct('B');
    cout<<product->GetProduct()<<endl;

    product = factory.MakeProduct('C');
    cout<<product->GetProduct()<<endl;
    return 0;
}

有一天，老板又要求： 将新产品 Product_D 加入到生产。简单工厂模式虽然满足了按要求生产对应的产品，

但无法扩展新产品。于是实现了工厂方法模式：

首先产品部分添加Product_D ：

class Product_D:public AbsProduct{
public:
    Product_D(){}
    virtual string GetProduct(){return "Product_D";}
};

工厂部分改为：

class AbsFactory{
public:
    AbsFactory(){}
    virtual AbsProduct* MakeFroduct() = 0;
};

class Factory_A:public AbsFactory{
public:
    Factory_A(){}
    virtual AbsProduct* MakeFroduct(){return new Product_A;}
};
class Factory_B:public AbsFactory{
public:
    Factory_B(){}
    virtual AbsProduct* MakeFroduct(){return new Product_B;}
};
class Factory_C:public AbsFactory{
public:
    Factory_C(){}
    virtual AbsProduct* MakeFroduct(){return new Product_C;}
};

class Factory_D:public AbsFactory{
public:
    Factory_D(){}
    virtual AbsProduct* MakeFroduct(){return new Product_D;}
};

实现部分：

#include <iostream>
#include <string>
using namespace std;
#include "Factory.h"
#include "Product.h"

int main()
{
    AbsFactory* factory = new Factory_A;
    AbsProduct* product = factory->MakeFroduct();
    cout<<product->GetProduct()<<endl;

    factory = new Factory_B;
    product = factory->MakeFroduct();
    cout<<product->GetProduct()<<endl;

    factory = new Factory_C;
    product = factory->MakeFroduct();
    cout<<product->GetProduct()<<endl;

    factory = new Factory_D;
    product = factory->MakeFroduct();
    cout<<product->GetProduct()<<endl;

    return 0;
}

老板又要求了，“现在我们公司就主打这四个产品了，你们要定期更新这些产品。”

这样工厂方法虽然满足了按客户要求生产对应产品，而且也满足了扩展新产品的要求，

但无法满足新产品的更新换代。于是抽象工厂模式出来了......

对于我们的例子而已，假设公司的产品A1,B1,C1,D1为一起产品，A2,B2,C2,D2为二期产品。

则A1，A2，A3......为同一族产品。而A1,B1,C1,D1为同一等级产品。如果只工厂生产同一等级

产品，则是工厂方法模式。如果产生了不同等级产品则为抽象工厂模式。