C++ assert与try, catch

assert：根据判断条件，如果不满足则抛出异常，但仅限于Debug模式

try, catch：Debug模式和Release模式均可。

try, catch详细用法: https://blog.csdn.net/qq_40191710/article/details/81063878

                              https://www.jb51.net/article/80913.htm

更新一下上面链接的代码 :-)

C++的异常处理的基本思想大致可以概括为传统错误处理机制、通过函数返回值来处理错误。

1）C++的异常处理机制使得异常的引发和异常的处理不必在同一个函数中，这样底层的函数可以着重解决具体问题，而不必过多的考虑异常的处理。上层调用者可以再适当的位置设计对不同类型异常的处理。
2）异常是专门针对抽象编程中的一系列错误处理的，C++中不能借助函数机制，因为栈结构的本质是先进后出，依次访问，无法进行跳跃，但错误处理的特征却是遇到错误信息就想要转到若干级之上进行重新尝试，如图

3）异常超脱于函数机制，决定了其对函数的跨越式回跳。
4）异常跨越函数

异常基本语法

1） 若有异常则通过throw操作创建一个异常对象并抛掷。
2） 将可能抛出异常的程序段嵌在try块之中。控制通过正常的顺序执行到达try语句，然后执行try块内的保护段。
3） 如果在保护段执行期间没有引起异常，那么跟在try块后的catch子句就不执行。程序从try块后跟随的最后一个catch子句后面的语句继续执行下去。
4） catch子句按其在try块后出现的顺序被检查。匹配的catch子句将捕获并处理异常（或继续抛掷异常）。
5） 如果匹配的处理器未找到，则运行函数terminate将被自动调用，其缺省功能是调用abort终止程序。
6）处理不了的异常，可以在catch的最后一个分支，使用throw语法，向上扔
7）异常机制与函数机制互不干涉，但捕捉的方式是基于类型匹配。捕捉相当于函数返回类型的匹配，而不是函数参数的匹配，所以捕捉不用考虑一个抛掷中的多种数据类型匹配问题。
catch代码块必须出现在try后，并且在try块后可以出现多个catch代码块，以捕捉各种不同类型的抛掷。
异常机制是基于这样的原理：程序运行实质上是数据实体在做一些操作，因此发生异常现象的地方，一定是某个实体出了差错，该实体所对应的数据类型便作为抛掷和捕捉的依据。
8）异常捕捉严格按照类型匹配
 异常捕捉的类型匹配之苛刻程度可以和模板的类型匹配媲美,它不允许相容类型的隐式转换,比如,抛掷char类型用int型就捕捉不到．例如下列代码不会输出“int exception.”，从而也不会输出“That's ok.” 因为出现异常后提示退出

一、正确处理异常实例：

int divide(int x, int y)           // 抛异常
{
	if (y == 0)
	{
		throw x;
	}
	return x / y;
}
int main()
{
	try//try和catch连用
	{
		cout << "8/2 = " << divide(8, 2) << endl;
		cout << "10/0 =" << divide(10, 0) << endl;//抛出异常
	}
	//catch接住异常
	catch (int e)
	{
		cout << "e" << " is divided by zero!" << endl;
	}
	catch (...)
	{
		cout << "未知异常" << endl;
	}

	cout << "ok" << endl;
	system("pause");
	return 0;
}

二、将异常上抛，无法处理异常导致错误：

/如果main函数不做异常处理：将会发生错误：

// 假设我们我们要做 x/y ，y就不能为0 
void divide(int x, int y)      //抛异常
{
	if (y == 0)  // y为0 就是 异常
	{
		throw x;  //抛出 int类型 异常 （简单）  ，如果是一个类就变得复杂了
	}

	cout << "divide结果:" << x / y << endl;
}

void myDivide(int x, int y)
{
	try
	{
		divide(x, y);
	}
	catch (...)
	{
		cout << "我接受了 divide的异常 但是我没有处理 我向上抛出" << endl;
		throw;    //接收了异常之后继续往外抛
	}
}


void main()
{
	myDivide(100, 0);      //main函数不做异常处理，将会发生错误。

	cout << "hello..." << endl;
	system("pause");
	return;
}

三、扔出异常与catch中数据类型不符，最后无法处理异常导致错误：

int main() {
	try {
		throw 'H';  // 因为扔的是一个 char 的类型，接收的是一个int类型，会接收不了
	}
	catch (int) { //本来char可以隐式转化为int 类型的，可是需要严格按照类型，会去接接不了
		cout << "int exception.\n";
	}
	cout << "That's ok.\n";
}

四、异常被抛出后，从进入try块起，到异常被抛掷前，这期间在栈上的构造的所有对象，都会被自动析构。析构的顺序与构造的顺序相反。这一过程称为栈的解旋(unwinding)。

class MyException {}; 
  
class Test 
{ 
public: 
  Test(int a = 0, int b = 0) 
  { 
    this->a = a; 
    this->b = b; 
    cout << "Test 构造函数执行" << "a:" << a << " b: " << b << endl; 
  } 
  void printT() 
  { 
    cout << "a:" << a << " b: " << b << endl; 
  } 
  ~Test() 
  { 
    cout << "Test 析构函数执行" << "a:" << a << " b: " << b << endl; 
  } 
private: 
  int a; 
  int b; 
}; 
  
void myFunc() throw (MyException) 
{ 
  Test t1; 
  Test t2; 
  
  cout << "定义了两个栈变量,异常抛出后测试栈变量的如何被析构" << endl; 
  
  throw MyException(); 
} 
  
int main() 
{ 
  //异常被抛出后，从进入try块起，到异常被抛掷前，这期间在栈上的构造的所有对象， 
  //都会被自动析构。析构的顺序与构造的顺序相反。 
  //这一过程称为栈的解旋(unwinding) 
  try
  { 
    myFunc(); 
  } 
  //catch(MyException &e) //这里不能访问异常对象 
  catch (MyException) //这里不能访问异常对象 
  { 
    cout << "接收到MyException类型异常" << endl; 
  } 
  catch (...) 
  { 
    cout << "未知类型异常" << endl; 
  } 
  
  return 0; 
}