量化交易之C++篇 - 异常基本处理、异常变量的生命周期、异常的多态使用、使用系统提供的标准异常、自己编写异常类

// 异常基本处理
#include <iostream>
#include <string>

using namespace std;

class MyException { // 自定义异常类

public:
  void printError() {
    cout << "自定义的异常" << endl;
  }

};

class Person {

public:
  Person(string name) {
    this->name = name;
    cout << "Person: " << this->name << " 构造函数" << endl;
  }

  ~Person() {
    this->name = name;
    cout << "Person: " << this->name << " 析构函数" << endl;
  }

private:
  string name;
};

int myDevide(int a, int b) {

  if (0 == b) {
    //throw - 1; // 抛出 int 类型的异常;
    //throw 3.14; // 抛出 double 类型的异常;
    //throw 'a'; // 抛出 char 类型的异常;(这三句代码谁先抛出异常, 就处理谁)

    // 栈解旋: 从try开始 到 throw 抛出异常之前 所有栈上的对象 都会被释放; 这个过程被称为栈解旋。
    Person person1("roger");
    Person person2("rei ri");
    Person* person3 = new Person("xiangkusu"); // 堆区的对象, 就没有被释放

    throw MyException(); // 匿名对象 (相当于调用了一个无参构造函数)
    delete person3; // 因为 MyException() 异常已经抛出, 所以 person3 的析构函数不会调用
  }

  return a / b;
}

void test01() {

  int a = 10;
  int b = -10;

  try {
    myDevide(a, 0);
  }
  catch (int) { // 捕获 int 异常
    cout << "int 类型异常捕获" << endl;
  }
  catch (double) {
    throw; // 如果不想处理这个异常, 可以继续向上抛出
    cout << "double 类型异常捕获" << endl;
  }
  catch (MyException exception) {
    cout << "MyException 类型异常捕获" << endl;
    exception.printError();
    throw;
    
  }
  catch (...) { // 捕捉其它异常
    cout << "char 类型异常捕获" << endl;
  }
}

int main() {

  try {
    test01();
  }
  catch(double) {
    cout << "main double 类型异常捕获" << endl;
  }
  catch (...) {
    cout << "main other 类型异常捕获" << endl;
  }

  return EXIT_SUCCESS;
}

// 异常变量的生命周期
#include <iostream>

using namespace std;

class MyException {

public:
  MyException() {
    cout << "MyException 默认构造 函数" << endl;
  }

  MyException(const MyException& exception) {
    cout << "MyException 拷贝构造 函数" << endl;
  }

  ~MyException() {
    cout << "MyException 析构函数" << endl;
  }
};


void doWork() {
  throw new MyException();
  //throw MyException();
}

void test01() {

  try {
    doWork();
  }
  catch(MyException *exception) {
    cout << "*exception 异常" << endl;

    delete exception; // 异常对象的指针变量, 需要手动释放;
  }
  catch (MyException &exception) {
    cout << "exception 异常" << endl;
  }
  catch (...) {
    cout << "... 异常" << endl;
  }
}


int main() {

  test01();

  return EXIT_SUCCESS;
}

// 异常的多态使用
#include <iostream>

using namespace std;

class BaseException {

public:
  virtual void printError() {
    cout << "BaseException printError" << endl;
  }

};

class NullPointerException: public BaseException {
  
public:
  virtual void printError() {
    cout << "NullPointerException printError" << endl;
  }

};

class OutOfRangeException: public BaseException {

public:
  virtual void printError() {
    cout << "OutOfRangeException printError" << endl;
  }

};


void doWork() {
  //throw NullPointerException();
  throw OutOfRangeException();
}


void test01() {

  try {
    doWork();
  }
  catch(BaseException &baseException) {
    baseException.printError();
  }
  catch (NullPointerException &nullPointerException) {
    nullPointerException.printError();
  }
  catch (OutOfRangeException &outOfRangeException) {
    outOfRangeException.printError();
  }
  catch (...) {
    cout << "... 异常" << endl;
  }
}


int main() {

  test01();

  return EXIT_SUCCESS;
}

// 使用系统提供的标准异常
#include <iostream>
#include <string>

#include <stdexcept> // 系统提供的标准异常 要包含头文件;

using namespace std;

class Person {

public:
  Person(string name, int age) {
    this->name = name;

    if (age < 0 || age > 200) {

      throw length_error("长度越界");

      //throw out_of_range("年龄越界了!");
    }
  }

  string name;
  int age;
};


void test01() {
  try {
    Person person("roger", 201);
  }
  catch(out_of_range& exception) {
    cout << "out_of_range exception: " << exception.what() << endl; // exception.what(): 抛出异常时的错误提示
  }
  catch (length_error& exception) {
    cout << "length_error exception: " << exception.what() << endl;
  }
  catch (...) {
    cout << "... exception" << endl;
  }
}


int main() {

  test01();

  return EXIT_SUCCESS;
}

// 自己编写异常类
#include <iostream>
#include <string>

using namespace std;

class MyOutOfRangeException : public exception { // exception: 系统提供的异常基类

public:

  MyOutOfRangeException(string errorInfo) {
    this->errorInfo = errorInfo;
    cout << "MyOutOfRangeException: 有参构造函数" << endl;
  }

  virtual ~MyOutOfRangeException()
  {
    cout << "~MyOutOfRangeException: 析构函数" << endl;
  }

  virtual char const* what() const
  {
    return (this->errorInfo).c_str(); // string 转 char*
  }

private:
  string errorInfo;
};

class Person {

public:
  Person(string name, int age) {
    this->name = name;

    if (age < 0 || age > 200) {
      throw MyOutOfRangeException("so old");
    }
  }
  string name;
  int age;
};

void test01() {
  try {
    Person person("roger", 201);
  }
  catch (MyOutOfRangeException& myOutOfRangeException) { // 自定义异常类
    cout << "MyOutOfRangeException exception: " << myOutOfRangeException.what() << endl;
  }
  catch (...) {
    cout << "... exception" << endl;
  }
}

int main() {

  test01();

  return EXIT_SUCCESS;
}