C++设计模式之简单工厂模式

简单工厂模式用于创建对象，添加新类不影响以前的代码。
核心思想是virtual函数的应用，降低层与层之间的耦合度。

//简单工厂模式
#include<iostream>
using namespace std;
//基类
class COperation
{
public:
    int m_nFirst;
    int m_nSecond;
    virtual double GetResult()
    {
        double dResult = 0;
        return dResult;
    }
};
//加法
class AddOperation :public COperation
{
public:
    virtual double GetResult()
    {
        return m_nFirst + m_nSecond;
    }
};
//减法
class SubOperation :public COperation
{
    virtual double GetResult()
    {
        return m_nFirst - m_nSecond;
    }
};
//工厂类
class CCalculatorFactory
{
public:
    static COperation* Creat(char eOperator);
};

COperation * CCalculatorFactory::Creat(char eOperator)
{
    COperation *oper;
    switch (eOperator)
    {
    case'+':
        oper = new AddOperation();
        break;
    case'-':
        oper = new SubOperation();
        break;
    default:
        oper = new AddOperation();
        break;
    }
    return oper;
}

int main()
{
    int a, b;
    cin >> a >> b;
    COperation *op = CCalculatorFactory::Creat('-');
    op->m_nFirst = a;
    op->m_nSecond = b;
    cout << op->GetResult() << endl;

    system("pause");
    return 0;
}

（2）策略模式

//策略模式
#include<iostream>
using namespace std;
//策略基类
class COperation
{
public:
    int m_nFirst;
    int m_nSecond;
    virtual double GetResult()
    {
        double dResult;
        return dResult;
    }
};
//策略具体类，加法类
class AddOperattion :public COperation
{
public:
    AddOperattion(int a, int b)
    {
        m_nFirst = a;
        m_nSecond = b;
    }
    virtual double GetResult()
    {
        return m_nFirst + m_nSecond;
    }
};

class Context
{
private:
    COperation * op;
public:
    Context(COperation * temp)
    {
        op = temp;
    }
    double GetResult()
    {
        return op->GetResult();
    }
};

int main()
{
    int a, b;
    char c;
    cin >> a >> b;
    cout << "请输入运算符：";
    cin >> c;
    switch (c)
    {
    case'+':
        Context * context = new Context(new AddOperattion(a, b));
        cout << context->GetResult() << endl;
        break;
    default:
        break;
    }
    return 0;
}

//修改，策略与工厂的结合
class Context
{
private:
    COperation * op;
public:
    Context(char cType)
    {
        switch (cType)
        {
        case'+':
            op = new AddOperattion(3, 8);
            break;
        default:
            op = new AddOperattion();
            break;
        }
    }
    double GetResult()
    {
        return op->GetResult();
    }
};
int main()
{
    int a, b;
    cin >> a, b;
    Context *test = new Context('+');
    cout << test->GetResult() << endl;
    return 0;
}

策略模式将方法与对象分离出来，进一步降低了耦合度，简单工厂和策略模式都是为了对象变化或者方法发生变化不会只影响到程序的一个环节。

设计模式六大原则
1，单一职责原则。对于一个类来说，仅有一个外部因素使其发生变化，如果能够想到多于一个因素去改变一个类，那么这个类就不再是单一职责的类。
2，开放封闭原则
即为可扩展但不可修改性，对于扩展是开放的，对于修改是封闭的。对于需求，通过增加代码改变，而不是修改。
3，李氏代还原则
父类替换为子类，不会发生变化，为里氏代还原则。
4，依赖导致原则
细节依赖抽象，针对接口编程，而不是对具体的实现方法编程。高层模块不依赖底层模块，两者均依赖于抽象。