量化交易之C++篇 - 多态案例-计算器案例

#include <iostream>

using namespace std;

class Calculator {

public:

	Calculator() {
		this->a = 0;
		this->b = 0;
	}

	Calculator(int a, int b) {
		this->a = a;
		this->b = b;
	}

	void setValueA(int value) {
		this->a = value;
	}

	void setValueB(int value) {
		this->b = value;
	}

	int getValueA() {
		return this->a;
	}

	int getValueB() {
		return this->b;
	}

	void showInfomation() {
		cout << "a: " << this->a << "  b: " << this->b << endl;
	}


	int getResult(string operType) {

		int result = 0;

		if ("+" == operType) {
			result = this->a + this->b;
		} else if ("-" == operType) {
			result = this->a - this->b;
		} else {
			cout << operType << " 是什么妖魔鬼怪?" << endl;
		}

		return result;
	}

private:
	int a;
	int b;
};

void test01() {

	Calculator calculator;
	calculator.showInfomation();
	cout << calculator.getResult("-") << endl;


	calculator.setValueA(19);
	calculator.setValueB(20);
	calculator.showInfomation();
	cout << calculator.getResult("+") << endl;

}

// 利用多态实现计算器
class BaseCalculator {

public:
	BaseCalculator() {

		cout << "BaseCalculator alloc" << endl;

		this->a = 0;
		this->b = 0;
	}

	BaseCalculator(int a, int b) {

		cout << "BaseCalculator(int a, int b) alloc" << endl;

		this->a = a;
		this->b = b;
	}

	// 纯虚函数
	// 如果父类中有纯虚函数, 子类继承父类后就必须实现 纯虚函数;
	// 如果父类中有纯虚函数, 父类就无法实例化对象了;
	// 有纯虚函数的类, 通常被称为抽象类;
	virtual int getResult() = 0;

	void setValueA(int valueA) {
		this->a = valueA;
	}

	void setValueB(int valueB) {
		this->b = valueB;
	}

	virtual ~BaseCalculator() {
		cout << "BaseCalculator dealloc" << endl;
	}

protected:
	int a;
	int b;

};

class PlusCalculator : public BaseCalculator {

public:
	PlusCalculator(int a, int b) {

		cout << "PlusCalculator(int a, int b) alloc" << endl;

		this->a = a;
		this->b = b;
	}

	virtual int getResult() {
		return this->a + this->b;
	}

	virtual ~PlusCalculator() {
		cout << "PlusCalculator dealloc" << endl;
	}

};


class SubCalculator : public BaseCalculator {

public:
	SubCalculator(int a, int b) {

		cout << "SubCalculator alloc" << endl;

		this->a = a;
		this->b = b;
	}

	virtual int getResult() {
		return this->a - this->b;
	}

	virtual ~SubCalculator() {
		cout << "SubCalculator dealloc" << endl;
	}

};

void test02() {
	/*
		BaseCalculator alloc
		PlusCalculator(int a, int b) alloc
		30
		PlusCalculator dealloc
		BaseCalculator dealloc
		BaseCalculator alloc
		SubCalculator alloc
		4
		SubCalculator dealloc
		BaseCalculator dealloc
	*/

	BaseCalculator* abstractCalculator = new PlusCalculator(10, 20); // 多肽: 父类指针指向 子类对象;

	cout << abstractCalculator->getResult() << endl;
	delete abstractCalculator;
	//abstractCalculator = NULL;

	abstractCalculator = new SubCalculator(19, 15);
	cout << abstractCalculator->getResult() << endl;
	delete abstractCalculator;
}

class MultiCalculator : public BaseCalculator {

public:

	MultiCalculator() {
		cout << "MultiCalculator alloc" << endl;
	}

	MultiCalculator(int a, int b) {

		cout << "MultiCalculator(int a, int b) alloc" << endl;

		this->a = a;
		this->b = b;
	}

	virtual int getResult() {
		return this->a * this->b;
	}

	~MultiCalculator() {
		cout << "MultiCalculator dealloc" << endl;
	}
};

class DivCalculator : public BaseCalculator {

public:

	DivCalculator() {
		cout << "DivCalculator alloc" << endl;
	}

	DivCalculator(int a, int b) {

		cout << "DivCalculator(int a, int b) alloc" << endl;

		this->a = a;
		this->b = b;
	}

	virtual int getResult() {

		if (0 == this->b) {
			cout << "分母不能为空" << endl;
			return 0;
		}

		return this->a / this->b;
	}

	~DivCalculator() {
		cout << "DivCalculator dealloc" << endl;
	}
};

void test03() {

	MultiCalculator* multiCalculator = new MultiCalculator(11, 9);
	cout << multiCalculator->getResult() << endl;
	delete multiCalculator;

	DivCalculator *divCalculator = new DivCalculator(10, 3);
	cout << divCalculator->getResult() << endl;
	delete divCalculator;
}

int main() {

	//test01();

	//test02();

	test03();

	return EXIT_SUCCESS;
}