面对对象与面对过程的代码对比demo

根据上一篇博客 引出面对对象跟面对过程的区别 现在用代码实现
写一个简单的计算器demo

#include <iostream>

using namespace std;

//获取一个数字
int getNumber(void)
{
	int num = 0;

	cout << "please input a nubmer: ";

	cin >> num;

	return num;
}

//获取一个操作符
char getOperater(void)
{
	char op;

	cout << "please input a operator: ";

	cin >> op;

	return op;
}

//计算结果
int calculate(int numA, char op, int numB)
{
	int result = 0;

	switch (op)
	{
	case '+':
		result = numA + numB;
		break;

	case '-':
		result = numA - numB;
		break;

	case '*':
		result = numA * numB;
		break;

	case '/':
		if (0 == numB)
		{
			result = -1;
		}
		else
		{
			result = numA / numB;
		}

		break;

	default:
		result = 0;
	}

	return result;
}

//输出结果
void print(int numA, char op, int numB)
{
	cout << numA << op << numB << "=" << calculate(numA, op, numB) << endl;
}


int main(void)
{
	int numA = 0;
	int numB = 0;
	char op;

	//获取一个数字
	numA = getNumber();

	//获取一个操作符
	op = getOperater();

	//获取一个数字
	numB = getNumber();

	//输出
	print(numA, op, numB);

	return 0;
}

好好思考上述代码 是面对过程的 那么面对对象的代码是怎么样的呢

#if 1

#include <iostream>

using namespace std;


//设计计算器基类
class Operator
{
public:
	Operator() {}
	Operator(int _x, int _y)
	{
		numA = _x;
		numB = _y;
	}
	virtual ~Operator() {}

	//计算结果
	virtual int getResult() = 0;

public:
	int numA;
	int numB;
};

//加法类
class AddOperator :public Operator
{
public:
	AddOperator() {}
	AddOperator(int _x, int _y):Operator(_x, _y) {}
	~AddOperator() {}

	// 通过 Operator 继承
	virtual int getResult() override
	{
		int result = 0;

		result = numA + numB;

		return result;
	}
};

//减法类
class SubOperator :public Operator
{
public:
	SubOperator() {}
	SubOperator(int _x, int _y) :Operator(_x, _y) {}
	~SubOperator() {}

	// 通过 Operator 继承
	virtual int getResult() override
	{
		int result = 0;

		result = numA - numB;

		return result;
	}
};


//乘法类
class MulOperator :public Operator
{
public:
	MulOperator() {}
	MulOperator(int _x, int _y) :Operator(_x, _y) {}
	~MulOperator() {}

	// 通过 Operator 继承
	virtual int getResult() override
	{
		int result = 0;

		result = numA * numB;

		return result;
	}
};


//除法类
class DivOperator :public Operator
{
public:
	DivOperator() {}
	DivOperator(int _x, int _y) :Operator(_x, _y) {}
	~DivOperator() {}

	// 通过 Operator 继承
	virtual int getResult() override
	{
		int result = 0;

		if (0 == numB)
		{
			return -1;
		}

		result = numA / numB;

		return result;
	}
};


//创建对象的简单工厂类
class OperatorFactory
{
public:
	Operator * createOperator(int _x, int _y, string op)
	{
		Operator * pOperator = nullptr;

		switch (op[0])
		{
		case '+':
			pOperator = new AddOperator(_x, _y);
			break;
		case '-':
			pOperator = new SubOperator(_x, _y);
			break;
		case '*':
			pOperator = new MulOperator(_x, _y);
			break;
		case '/':
			pOperator = new DivOperator(_x, _y);
			break;
		}
	}
};


int main(void)
{
	
	OperatorFactory factory;

	Operator *pOperator = nullptr;

	pOperator = factory.createOperator(15, 3, "/");

	cout << "15 / 3 = " << pOperator->getResult() << endl;

	return 0;
}
#endif

可以看出很根本的三大面对对象的特点 封装 继承 多态
（因为方便观看写在一个文件内 严格意义上这种写法在工作中并不能使用）