设计模式 -- 工厂模式

看了一些别的工厂示例，挺不靠谱， 这个是比较使用的一个， 用了容器map,  GetInstance可以传入一些有用参数， 好久没写c++ code了，  被sll带到沟里了， :P

#ifndef LOGICFUNCCALC_H
#define LOGICFUNCCALC_H

#include <iostream>
#include <map>
#include <string>

class LogicFuncCalcBase;
typedef LogicFuncCalcBase* (*FactoryFunction)(int );
class LogicFuncCalcFactory
{
public:
    static void Register(std::string name, FactoryFunction instanceFunction)
    {
        m_FactoryFunctions[name] = instanceFunction;
    }
    static LogicFuncCalcBase* GetInstance(std::string name, int inputnum=1)
    {
        if (m_FactoryFunctions.count(name))
        {
            return m_FactoryFunctions[name](inputnum);
        }
        else
        {
            return NULL;
        }
    }
private:
    static std::map<std::string, FactoryFunction> m_FactoryFunctions;
};


class LogicFuncCalcBase
{
public:
    virtual char calculate(char * input) = 0;
};

class NotCalc : public LogicFuncCalcBase
{
public:

    NotCalc(int inputnum=1):m_inputnum(1)
    {
        if (inputnum != 1)
        {
            std::cout << "input can only be 1!So it is changed to !" << std::endl;
        }
    }

    char calculate(char * input)
    {

        //std::cout << "not calculated!" << std::endl;
        if (input[0] == 'f' ){
            return 't';
        }
        return 'f';
    }

    static LogicFuncCalcBase* CreateInstance(int inputnum=1)
    {
        return new NotCalc(inputnum);
    }

private:
    const int m_inputnum;
};

class AndCalc : public LogicFuncCalcBase
{
public:

    AndCalc(int inputnum=1):m_inputnum(inputnum){}

    char calculate(char * input)
    {
        //std::cout << "and calculated!" << std::endl;
        for (int i=0;i<m_inputnum;i++){
            if(input[i]=='f'){
                return 'f';
            }
        }
        return 't';
    }
    static LogicFuncCalcBase* CreateInstance(int inputnum=1)
    {
        return new AndCalc(inputnum);
    }

private:
    const int m_inputnum;
};

class OrCalc : public LogicFuncCalcBase
{
public:

    OrCalc(int inputnum=1):m_inputnum(inputnum){}

    char calculate(char * input)
    {
        //std::cout << "or calculated!" << std::endl;
        for (int i=0;i<m_inputnum;i++){
            if(input[i]=='t'){
                return 't';
            }
        }
        return 'f';
    }

    static LogicFuncCalcBase* CreateInstance(int inputnum=1)
    {
        return new OrCalc(inputnum);
    }

private:
    const int m_inputnum;
};

class XorCalc : public LogicFuncCalcBase
{
public:

    XorCalc(int inputnum=1):m_inputnum(inputnum){}

    char calculate(char * input)
    {
        //std::cout << "xor calculated!" << std::endl;
        bool res = false;
        for (int i=0;i<m_inputnum;i++){
            if(input[i]=='t'){
                res^=true;
            }else{
                res^=false;
            }
        }
        if (res == true) {
            return 't';
        }
        return 'f';
    }

    static LogicFuncCalcBase* CreateInstance(int inputnum=1)
    {
        return new XorCalc(inputnum);
    }

private:
    const int m_inputnum;
};

/*
int main()
{
 LogicFuncCalcFactory::Register("not", &NotCalc::CreateInstance);
 LogicFuncCalcFactory::Register("and", &AndCalc::CreateInstance);
 LogicFuncCalcFactory::Register("or", &OrCalc::CreateInstance);
 LogicFuncCalcFactory::Register("xor", &XorCalc::CreateInstance);

 DeviceBase* pShape = NULL;
 pShape = DeviceFactory::GetInstance("singleton");
 if (NULL == pShape)
 {
  std::cout << "Can't find the produce in the factory!" << std::endl;
 }
 else
 {
  pShape->Draw();
  delete pShape;
  pShape = NULL;
 }
 return 0;
}
*/
#endif // LOGICFUNCCALC_H

；