03 04 大话设计模式C++实现之拍摄UFO和求职考研两不误——单一职责原则和开闭原则

/*
单一职责原则
拍摄UFO, 单一职责原则就一个类而言，应该仅有一个引起它变化的原因
比如我们写一个窗体应用程序，一般都会生成一个Form1这样的类，于是我们就把各种各样的代码，
像某种商业运算的算法啊，访问数据库的SQL语句等都写到这样的类中，就意味着无论什么样的需求
都需要改这个窗体类，这其实很糟糕，维护很麻烦，复用不可能，也缺乏灵活性

如果一个类承担过多的职责，就等于把这些职责耦合到一起，一个职责的变化就可能削弱或者抑制
其他职责的能力。这种耦合会导致脆弱的设计，当变化发生时，设计会遭遇到意想不到的破坏，软
件设计真正要做的就是发现职责并把职责进行分离。如果能够想到多于一个动机去改变类，那么这
个类就具有多于一个的职责
*/

/*
开放-封闭原则
对于扩展开放，对于更改封闭。这样的设计使得面对需求的改变时系统保持相对的稳定，从而使得
系统可以在第一个版本以后不断推出新的版本，绝对的对修改关闭是不可能的。无论模块多么的封
闭，都会存在一些无法对之封闭的变化。既然不能完全封闭，设计人员必须对于他设计的模块应该
对哪种变化封闭作出选择。他必须先猜测出最有可能发生变化的种类，然后构造抽象来隔离那些变
化
*/

//开闭实现加减乘除运算
/*------------------------------------------------------------------------------------
一开始的需求实现两个数的加法，但需求后期发生改变要求同时实现加减乘除，因此需要实现一
个基类用于读取数据和输出结果，而具体的运算是产生变化的部分，实现如下：
*/

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
#include<stdexcept>
using namespace std;

//基类（运算类）
class ComputeOperation
{
private:
    double a;
    double b;
public:
    virtual double getResult() = 0;
    
    void setA(double x)
    {
        this->a = x;
    }
    void setB(double y)
    {
        this->b = y;
    }
    double getA()
    {
        return this->a;
    }
    double getB()
    {
        return this->b;
    }
};

class Add :public ComputeOperation
{
public:
    virtual double getResult()
    {
        cout << getA() + getB() << endl;
        return getA() + getB();
    }
};
//需求改变，要求实现其他运算
class Sub :public ComputeOperation
{
public:
    virtual double getResult()
    {
        cout << getA() - getB() << endl;
        return getA() - getB();
    }
};
class Mul :public ComputeOperation
{
public:
    virtual double getResult()
    {
        cout << getA() * getB() << endl;
        return getA() * getB();
    }
};
class Dev :public ComputeOperation
{
public:
    virtual double getResult()
    {
        if (getB() == 0) throw overflow_error("除数不能为0！");
        cout << getA() / getB() << endl;
        return getA() / getB();
    }
};

//客户端类依赖于运算的基类
class Client
{
public:
    ComputeOperation *createCase(double a, char opra, double b)
    {
        ComputeOperation *oper = NULL;
        switch (opra)
        {
        case '+':
            oper = new Add;
            break;
        case '-':
            oper = new Sub;
            break;
        case '*':
            oper = new Mul;
            break;
        case '/':
            oper = new Dev;
            break;
        default:
            throw logic_error("输入错误或者计算类型错误");
        }
        oper->setA(a);
        oper->setB(b);
        oper->getResult();
        return oper;
    }
};

void test()
{
    
    Client client1;
    ComputeOperation *res1 = client1.createCase(10, '*', 0);
    Client client2;
    ComputeOperation *res2 = client2.createCase(10, '+', 0);
    Client client3;
    ComputeOperation *res3 = client3.createCase(10, '-', 0);
    try
    {
        Client client4;
        ComputeOperation *res4 = client4.createCase(10, '/', 0);
        
    }
    catch (overflow_error &e)
    {
        cout << e.what() << endl;
    }
    try 
    {
        Client client5;
        ComputeOperation *res5 = client5.createCase(10, 'x', 0);
    }
    catch (logic_error &l)
    {
        cout << l.what() << endl;
    }
}

int main()
{
    test();
    system("pause");
    return EXIT_SUCCESS;
}

/*
一般来说，如果开发工作开展不久就可以知道可能发生的变化，创建正确的抽象就越简单
开闭原则是面向对象设计的核心所在。遵循这个原则可以带来面向对象技术所声称的巨大
好处，也就是可维护、可扩展、可复用、灵活性好。开发人员应该仅对程序中频繁变化的
那些部分作出抽象，然而对于应用程序中的每一个部分都刻意地进行抽象并不是好主意，
拒绝不成熟的抽象和抽象一样的重要
*/