2.异常的抛出和匹配原则   

1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。

  

throw抛出的异常，必须要有类型匹配的catch所对应，如果没有类型匹配的catch，会直接报错，终止程序！

2. 被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。

当除数为0时，抛出异常，他会先找当前作用域的catch，如果没有，就会返回调用链中调用它的上一个中去找catch，如果没有catch，就会直接报错，终止程序。

 

同一位置可以有多个类型不用的catch，但是同一位置不可以有相同类型的catch，相同类型的catch必须分布在不同的位置（可以看作是提前catch）：

double Division(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
		throw "Division by zero condition!";// throw  const char*对象
	else
		return ((double)a / (double)b);
}
void Func()
{
    try
  {

	int len, time;
	cin >> len >> time;
	cout << Division(len, time) << endl; 
  }

  catch (const char* errmsg) //const char*类型
  {
		cout << errmsg << endl;
		// 记录日志，进行统一处理
  }

}
int main()
{
	try
	{
		Func();
	}
	catch (const char* errmsg) //const char*类型
	{
		cout << errmsg << endl;
		// 记录日志，进行统一处理
	}
	catch (int errid)  //int 类型
	{
		cout << errid << endl;
	}
	return 0;
}

throw抛出的可以是异常对象：

3. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似于函数的传值返回）

 当然，编译器会自动识别为将亡值，然后调用移动构造，直接构造。

4. catch(...)可以捕获任意类型的异常，问题是不知道异常错误是什么。

如果出现这种情况：new出的对象因为catch而导致执行顺序混乱，没有释放就会导致内存泄漏。

double Division(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
	{
		string s("Division by zero condition!");
		throw s;
	}
	else
		return ((double)a / (double)b);
}
void Func()
{
    //new的资源需要释放
	int* p1 = new int[10];

	try
	{
		int len, time;
		cin >> len >> time;
		cout << Division(len, time) << endl; // throw  const char*对象
		// func()   // throw double对象
	}

	catch (...)  // 表示可以捕获任意类型的异常
	{
		//cout << errmsg << endl;
		cout << "delete" << p1 << endl;
		delete[] p1;

		throw;  // 重新抛出，捕获到什么就抛出什么
	}
	//catch (const string& errmsg)
	//{
	//	//cout << errmsg << endl;
	//	cout << "delete" << p1 << endl;
	//	delete[] p1;

	//	throw errmsg;  // 重新抛出
	//}

	cout << "delete"<< p1 << endl;
	delete[] p1;
}

int main()
{
	try
	{
		Func();
	}
	catch (const char* errmsg) 
	{
		cout << errmsg << endl;
		// 记录日志，进行统一处理
	}
	catch (...)
	{
		cout << "未知异常" << endl;
	}

	return 0;
}

那么就可以在catch捕获异常里面，释放内存以后，再重新抛出异常throw;（但不知道是什么类型）  ，若无类型匹配就会直接停止程序，于是有 catch(...)可以捕获任意类型的异常，释放空间时，就可以直接在catch中写一次就可以。（但也不知道异常错误是什么）

所以为了在main中统一处理异常，这就要要求抛异常得规范，使得捕获以后可以识别异常类型。（后面继续看）

3.在函数调用链中异常栈展开匹配原则

1. 首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则

调到catch的地方进行处理。

  

前面我们提到了，try中是保护代码，如果try中throw抛异常以后，首先看有没有对应的catch（类型匹配），没有的话直接报错，停止程序，有的话直接跳到catch来进一步解决。

2. 没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。

当然不是当前函数栈没有对应的catch就直接终止程序，会依次返回调用链的上一层去寻找，

知道调用链结束，没找到就直接报错，停止程序

 

3. 如果到达main函数的栈，依旧没有匹配的，则终止程序。上述这个沿着调用链查找匹配的

catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(...)捕获任意类型的异

常，否则当有异常没捕获，程序就会直接终止。

 

当然程序一般不会随便就结束，若没有对应的catch捕获异常匹配，为了防止程序结束，就会在最后加一个catch(...){}，防止程序结束。

4.异常的特殊类型匹配（异常体系）

这就有了用子类抛异常，父类来捕获异常。什么意思呢？来看例子：

//规定一个异常的标准类
class Exception
{
public:
	Exception(const string& errmsg, int id)
		:_errmsg(errmsg)
		, _id(id)
	{}

	virtual string what() const
	{
		return _errmsg;
	}
protected:
	string _errmsg;
	int _id;
};

//我么们可以通过继承父类后，增加子类的成员变量来区分异常类型
class SqlException : public Exception
{
public:
	SqlException(const string& errmsg, int id, const string& sql)
		:Exception(errmsg, id)
		, _sql(sql)
	{}

	virtual string what() const
	{
		string str = "SqlException:";
		str += _errmsg;
		str += "->";
		str += _sql;

		return str;
	}
private:
	const string _sql;
};

class CacheException : public Exception
{
public:
	CacheException(const string& errmsg, int id)
		:Exception(errmsg, id)
	{}

	virtual string what() const
	{
		string str = "CacheException:";
		str += _errmsg;
		return str;
	}
};

class HttpServerException : public Exception
{
public:
	HttpServerException(const string& errmsg, int id, const string& type)
		:Exception(errmsg, id)
		, _type(type)
	{}

	virtual string what() const
	{
		string str = "HttpServerException:";
		str += _type;
		str += ":";
		str += _errmsg;

		return str;
	}

private:
	const string _type;
};

void SQLMgr()
{
	srand(time(0));
	if (rand() % 7 == 0)
	{
		throw SqlException("权限不足", 100, "select * from name = '张三'");
	}

	cout << "调用成功" << endl;
}

void CacheMgr()
{
	srand(time(0));
	if (rand() % 5 == 0)
	{
		throw CacheException("权限不足", 100);
		//throw 1;
	}
	else if (rand() % 6 == 0)
	{
		throw CacheException("数据不存在", 101);
	}

	SQLMgr();
}

void HttpServer()
{
	// ...
	srand(time(0));
	if (rand() % 3 == 0)
	{
		throw HttpServerException("请求资源不存在", 100, "get");
	}
	else if (rand() % 4 == 0)
	{
		throw HttpServerException("权限不足", 101, "post");
	}

	CacheMgr();
}

int main()
{
	while (1)
	{
		Sleep(1000);

		try 
        {
			HttpServer();
		}
		catch (const Exception& e) // 这里捕获父类对象就可以
		{
			// 多态
			cout << e.what() << endl;
		}

		catch (...)
		{
			cout << "Unkown Exception" << endl;
		}
	}

	return 0;
}

 可以来看一下结果：

 catch(...){}的作用就是方式其他无匹配的异常类型报错停止程序。

这里其实也用到了多态的调用，通过父类的引用，来调用重写以后的虚函数，从而实现多态调用。

这就很好的解决了问题。

 

C++ 提供了一系列标准的异常 ，我们可以在程序中使用这些标准的异常。

但是

实际中我们可以可以去继承 exception 类实现自己的异常类。但是实际中很多公司像上面一

样自己定义一套异常继承体系。因为 C++ 标准库设计的不够好用。

只需知道这些异常代表的意义：

（申请内存空间）

（越界访问）

5.异常安全