第一章 代码无错就是优？--简单工厂模式(读书笔记)

一：高耦合、低内聚，经过封装、继承、多态等面向对象设计方法实现低耦合、高内聚，使得程序易于维护、可复用、可扩展以及灵活性好。

二：尽可能的避免重复，尽量的复用。

三：聚合关系：聚合表示一种弱的”拥有“关系，体现的是A对象可以包含B对象，但B对象不是A对象的一部分

四：组合关系：组合关系是一种强的“拥有”关系，强调严格的部分与整体关系，部分与整体生命周期一样

五：编程是一门技术，学好了就是一门艺术

实例：计算器的实现

最简单的面向过程的计算器

#include<iostream>
#include<string>
using std::cout;
using std::endl;
using std::cin;
using std::string;


void main()
{
	cout<< "请输入数字A" << std::endl;  
    string stringA;  
    cin >> stringA;  
  
    cout << "请输入符号+-*/" << std::endl;  
    string stringC;  
    cin >> stringC;  
  
    cout << "请输入数字B" << std::endl;  
    string stringB;  
    cin >> stringB;  
  
    int iAnswer;  
    //运算  
    if (stringC == "+")  
        iAnswer = atoi(stringA.c_str()) + atoi(stringB.c_str());  
    if (stringC == "-")  
        iAnswer = atoi(stringA.c_str()) - atoi(stringB.c_str());  
    if (stringC == "*")  
        iAnswer = atoi(stringA.c_str()) * atoi(stringB.c_str());  
    if (stringC == "/")  
        iAnswer = atoi(stringA.c_str()) / atoi(stringB.c_str());  
  
    cout << "结果是:" << iAnswer<<endl;  
}

代码优化

#include<iostream>
#include<string>
using std::cout;
using std::endl;
using std::cin;
using std::string;

void main()
{
	try
	{
		cout<< "请输入数字A" << std::endl;  
		string stringA;  
		cin >> stringA;  
  
		cout << "请输入符号+-*/" << std::endl;  
		char charC;  
		cin >> charC;  
  
		cout << "请输入数字B" << std::endl;  
		string stringB;  
		cin >> stringB;

		string iAnswer("");

		switch (charC)
		{
		case '+':  
			iAnswer = atoi(stringA.c_str()) + atoi(stringB.c_str());  
			break;  
		case '-':  
			iAnswer = atoi(stringA.c_str()) - atoi(stringB.c_str());  
			break;  
		case '*':  
			iAnswer = atoi(stringA.c_str()) * atoi(stringB.c_str());  
			break;  
		case '/':  
			if (atoi(stringB.c_str()) != 0 )  
				iAnswer = atoi(stringA.c_str()) / atoi(stringB.c_str());  
			break;  
		default:
			break;
		}
		cout << "结果是:" << iAnswer<<endl; 
	}
	catch(...)
	{
		cout<<"您的输入有错"<<endl;
	}
}

增加业务封装

#include<iostream>
#include<string>
using std::cout;
using std::endl;
using std::cin;
using std::string;

struct Operation  
{  
    static double GetResult(double numberA, double numberB,char myOperator)  
    {  
        double retVal;  
        switch (myOperator)  
        {  
            case '+':  
                retVal = numberA + numberB;  
                break;  
            case '-':  
                retVal = numberA - numberB;  
                break;  
            case '*':  
                retVal = numberA * numberB;  
                break;  
            case '/':  
                retVal = numberA / numberB;  
                break;  
            default:  
                break;  
        }  
        return retVal;  
    }  
}; 

void main()
{
	try
	{
		cout<< "请输入数字A" << std::endl;  
		string stringA;  
		cin >> stringA;  
  
		cout << "请输入符号+-*/" << std::endl;  
		char charC;  
		cin >> charC;  
  
		cout << "请输入数字B" << std::endl;  
		string stringB;  
		cin >> stringB;

		cout<<"结果是："<<Operation::GetResult(atof(stringA.c_str()),atof(stringB.c_str()), charC); 
	}
	catch(...)
	{
		cout<<"您的输入有错"<<endl;
	}
}

面向对象

#include<iostream>
#include<string>
using std::cout;
using std::endl;
using std::cin;
using std::string;

//基类
class Operation
{
public:
	Operation():m_numberA(0),m_numberB(0)
	{
	};
	Operation(double numberA,double numberB):m_numberA(numberA),m_numberB(numberB)
	{
	};
	double getA()
	{
		return m_numberA;
	};
	double getB()
	{
		return m_numberB;
	};
	void setA(double number)  
    {  
        m_numberA = number;  
    };  
	void setB(double number)  
    {  
        m_numberB = number;  
    };  
	virtual double GetResult()//多态性
	{
		return 0;
	}
protected:
	double m_numberA;
	double m_numberB;
};

//加法类  
class OperationAdd :public Operation //继承
{  
public:  
    double GetResult()  
    {  
        double result = 0;  
        result = m_numberA + m_numberB;  
        return result;  
    }  
};  
//减法类  
class OperationSub :public Operation  
{  
public:  
    double GetResult()  
    {  
        double result = 0;  
        result = m_numberA - m_numberB;  
        return result;  
    }  
};  
//乘法类  
class OperationMul :public Operation  
{  
public:  
    double GetResult()  
    {  
        double result = 0;  
        result = m_numberA * m_numberB;  
        return result;  
    }  
};  
//除法类  
class OperationDiv :public Operation  
{  
public:  
    double GetResult()  
    {  
        double result = 0;  
        if ( m_numberB == 0 )  
            throw "除数不能为0";  
        result = m_numberA / m_numberB;  
        return result;  
    }  
};  
//计算工厂设计模式
class OperationFactory
{
public:
	static Operation* createOperate(char oper)  //封装
	{
		Operation* myOper=NULL;
		switch (oper)
		{
		case '+':
			myOper=new OperationAdd();
			break;
			case '-':  
            myOper = new OperationSub();  
            break;  
        case '*':  
            myOper = new OperationMul();  
            break;  
        case '/':  
            myOper = new OperationDiv();  
            break;  
		default:
			break;
		};
		return myOper;
	}
};

void main()
{
	int operaterA,operaterB;
	cout<<"请输入数字A"<<endl;
	cin>>operaterA;
	cout<<"请输入数字B"<<endl;
	cin>>operaterB;
	Operation* op=OperationFactory::createOperate('*');
	op->setA(operaterA);
	op->setB(operaterB);
	cout<<operaterA<<" * "<<operaterB<<" 的结果为： "<<endl;
	cout<<op->GetResult()<<endl;
}