工厂方法

    开始第一个实质性的博文，之前粗略的汇总了23中设计模式，下面该一一道来。
    首先就是这 工厂方法 (factory method)

    从简单工厂说起：
           1. 工厂类  Factory
           2. 工厂所能生产的产品的抽象 Product
                  2.1. 实际的产品 ProductA
                  2.2. 实际的产品 ProductB
                  2.3. ......
                  注：实际的产品都具备 Product 的基本功能 (即接口的实现)

           使用：用户那到工厂的实例，调用他的方法；传入参数 A 则生成的是 A 产品，B 则生成 B 产品；
                      而对用户来说，使用的方式都和 Product 一样，只是不同的产品最终的表现不同。
代码示例：
1. factory.h

#ifndef _FACTORY_H_
#define _FACTORY_H_

#include "operation.h"

class Factory
{
public:
    Factory();
    Operation* CreateOpteration(char* type);
};

#endif

2. factory.cpp

#include <cstring>
#include "factory.h"
#include "operation_add.h"
#include "operation_sub.h"

Factory::Factory()
{
}

Operation* Factory::CreateOpteration(char* type)
{
    Operation* op = NULL;
    if(0 == strcmp(type, "add"))
    {
        op = new OperationAdd();
    }
    else if (0 == strcmp(type, "sub"))
    {
        op = new OperationSub();
    }
    else
    {
        // error type
    }
    return op;
}

3. operation.h

#ifndef _OPERATION_H_
#define _OPERATION_H_

class Operation
{
public:
    Operation();
    void setA(int num);
    void setB(int num);
    virtual int GetResult();

protected:
    int m_numA;
    int m_numB;
};

#endif

4. operation.cpp

#include "operation.h"

Operation::Operation()
{
    m_numA = 0;
    m_numB = 0;
}

void Operation::setA(int num)
{
    m_numA = num;
}

void Operation::setB(int num)
{
    m_numB = num;
}

int Operation::GetResult()
{
    return 0;
}

5. operation_add.h

#ifndef _OPERATION_ADD_H_
#define _OPERATION_ADD_H_

#include "operation.h"

class OperationAdd : public Operation
{
public:
    OperationAdd();
    int GetResult();
};

#endif

6. operation_add.cpp

#include "operation_add.h"

OperationAdd::OperationAdd()
{
}

int OperationAdd::GetResult()
{
    return m_numA + m_numB;
}

7. operation_sub.h

#ifndef _OPERATION_SUB_H_
#define _OPERATION_SUB_H_

#include "operation.h"

class OperationSub : public Operation
{
public:
    OperationSub();
    int GetResult();
};

#endif

8. operation_sub.cpp

#include "operation_sub.h"

OperationSub::OperationSub()
{
}

int OperationSub::GetResult()
{
    return m_numA - m_numB;
}

9. test.cpp

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

int main(int argc, char* argv[])
{
    Operation* op = NULL;
    Factory fa;
    op = fa.CreateOpteration((char*)"add");
    if(NULL != op)
    {
        op->setA(1);
        op->setB(2);
    }
    std::cout << "1 add 2 : " << op->GetResult() << std::endl;

    delete op;
    op = NULL;
    op = fa.CreateOpteration((char*)"sub");
    if(NULL != op)
    {
        op->setA(1);
        op->setB(2);
    }
    std::cout << "1 sub 2 : " << op->GetResult() << std::endl;
    delete op;

    return 0;
}

       以上是一个简单工厂的实现，包括测测试代码。实现的功能：工厂可以产生 operation，至于最终产生哪种
operation，根据用户参数决定！ (代码在 linux gcc 4.4.3 编译运行通过)

       通过上述代码发现，要是现在增加一种 operation 则需要修改 factory 中生成产品的方法的实现，即违背了
开放封闭原则(这也是简单工厂没有进入 23 中设计模式的原因)，故有 工厂方法 出现。
       其实实质上，工厂方法 是将 简单工厂 中根据参数的判断扔给了用户；
      1. 产品 Product
          1.1. 产品 ProductA
          1.2. ......
      2. 创建着 Creator
          2.1. 创建者 CreatorA
          2.2. ......
      用户得到创建者 A 就可以创建出产品 A，......
代码示例:
1. product.h

#ifndef _PRODUCT_H_
#define _PRODUCT_H_

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

#endif

2. creater.h

#ifndef _CREATER_H_
#define _CREATER_H_

#include "product.h"

class Creater
{
public:
    virtual Product* FactoryMethod() = 0;
};

#endif

3. productA.h

#ifndef _PRODUCT_A_H_
#define _PRODUCT_A_H_

#include "product.h"

class ProductA : public Product
{
public:
    void operation();
};

#endif

4. productA.cpp

#include <iostream>
#include "productA.h"

void ProductA::operation()
{
    std::cout << "ProductA - operation" << std::endl;
}

5. createrA.h

#ifndef _CREATER_A_H_
#define _CREATER_A_H_

#include "product.h"
#include "creater.h"

class CreaterA : public Creater
{
public:
    Product* FactoryMethod();
};

#endif

6. createrA.cpp

#include <iostream>
#include "createrA.h"
#include "productA.h"
Product* CreaterA::FactoryMethod()
{
    std::cout << "CreaterA - FactoryMethod" << std::endl;
    Product* pt = new ProductA();
    return pt;
}

7. test.cpp

#include <iostream>
#include "product.h"
#include "creater.h"
#include "createrA.h"

int main(int argc, char* argv[])
{
    Creater* ct = new CreaterA();
    Product* pt = ct->FactoryMethod();

    pt->operation();

    delete ct;
    delete pt;
}

       上述是一个简单的 工厂方法 模式实现，非常的粗糙，见谅。
       由于在linux下，对画图工具还是清楚，故没有给出 UML 图，见谅 -_-!
       －－－ end －－－