量化交易之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;
}