目录
在C语言中处理错误的方式和缺陷有：
缺陷：
1.错误码不好设置，比如：除0操作，就不好返回错误码。如果返回一个数字，可能会有两层含义，是错误，还是结果呢。一般我们会在参数加一个输出型参数返回结果，再规定成功和失败返回的数字。
2.需要程序员去查找错误码对应的含义。比如：很多系统接口函数都是把错误码放到全局变量errno中，表示错误。
缺陷：并不能明确知道是什么错误。用户难以接收。
C++针对上面的不足，引入了异常的概念，不会终止程序，并且会将错误信息详细介绍。
int test(){
int a = 0;
int b = 0;
cin >> a >> b;
if (b == 0){
throw bad_exception("除0错误");//抛出异常
}
return a / b;
}
int main(){
try{
cout << test() << endl;//可能会出现异常代码
}
catch (const exception& e){
cout << e.what() << endl;//捕获异常
}
system("pause");
return 0;
}
异常是面向对象语言处理错误的一种方式。当一个函数出现自己无法处理的错误时，可以抛出异常，然后输的直接或者间接调用者处理这个错误。
有三个关键字：
注意：可以抛出任意类型的对象。抛出的异常必须捕获。try要和catch匹配使用，catch里的内容抛出异常时才执行，没有异常，不执行。
int test(){
int a = 0;
int b = 0;
cin >> a >> b;
if (b == 0){
throw "除0错误";//抛出异常,异常的描述
}
return a / b;
}
int main(){
try{
cout << test() << endl;//会出现异常的代码
}
//捕获异常
catch (const char* a){
cout << a << endl;
}
catch (...){
cout << "unknow exception" << endl;
}
system("pause");
return 0;
}异常时通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。
被选中的处理代码的调用链是，找到于该类型匹配且离抛出异常位置最近的那一个catch。
抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象。
catch(...)可以捕获任意类型的对象，主要是用来捕获没有显示捕获类型的异常，因为如果没有匹配的catch会终止程序。相当于条件判断中的else。问题是不知道异常错误是什么。
实际中抛出和捕获的类型不一定类型完全匹配，可以抛出派生类对象，使用基类来捕获，这个在实际生活中很实用。主要原因是：派生类可以赋值给基类。
异常的匹配规则：
如果在中间匹配的：
结论：按照函数调用链，一层一层往外找，直到找到匹配的catch块，直接跳到匹配的catch块执行，执行完catch，会继续往catch块后面的语句执行。相当于没有找到匹配的函数栈帧被释放了。
有可能单个的catch不能完全处理一个异常，在进行一些矫正处理后，需要交给更外层的调用链函数来处理。catch可以做完矫正操作，再将异常重新抛出，交给更上层的函数进行处理。
由于抛异常只要找到匹配的catch就直接跳到catch块执行，没有找到对应catch的函数就不会继续执行。这样导致函数的执行流回很乱。可能会导致一些问题。
构造函数完成对象的构造和初始化，最好不要再构造函数中抛出异常，否则可能导致对象不完整或者没有完全初始化
析构函数主要完成资源的清理，最好不要在析构函数中抛异常，否则可能导致内存泄漏。
C++异常经常会导致资源泄漏问题。比如：在new和delete中抛出异常，导致new出来的资源没有释放，导致内存泄漏。在lock和unlock中抛出异常，导致锁没有释放，导致死锁。
有两种解决办法：
// 这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() throw(A，B，C，D);
// 这里表示这个函数只会抛出bad_alloc的异常
void* operator new (std::size_t size) throw (std::bad_alloc);
// 这里表示这个函数不会抛出异常
void* operator new (std::size_t size, void* ptr) throw();
void* operator new (std::size_t size, void* ptr) noexcept;在实际中，并不是我们想抛什么异常就抛什么异常，这样会导致捕捉的时候不好捕捉。而是，会建立一个继承体系，建立一个异常类，派生类继承这个类，来定义出不同的异常。
到时候抛出异常，只需要用基类进行捕捉即可。
基类可以相当于是一个框架，派生类是具体的异常。然后去具体实现异常的内容，然后抛异常只需要抛派生类，捕捉异常只需要捕捉基类即可。
下面是一个简单的实现：
//基类
//异常
class Exception{
public:
Exception(const char* str = nullptr, int id = 0)
:_errmsg(str)
, _id(id)
{}
virtual void what()const = 0;
protected:
string _errmsg;//错误信息
int _id;//错误码
};
//派生类
//数据库异常
class SqlException :public Exception{
public:
SqlException(const char *str = nullptr, int id = 1)
:Exception(str, id)
{}
virtual void what()const{
cout << "error msg:" << _errmsg << endl;
cout << "error id:" << _id << endl;
}
};
//网络异常
class HttpException :public Exception{
public:
HttpException(const char *str = nullptr, int id = 2)
:Exception(str, id)
{}
virtual void what()const{
cout << "error msg:" << _errmsg << endl;
cout << "error id:" << _id << endl;
}
};
//缓存异常
class CacheException :public Exception{
public:
CacheException(const char *str = nullptr, int id = 3)
:Exception(str, id)
{}
virtual void what()const{
cout << "error msg:" << _errmsg << endl;
cout<< "error id:" << _id << endl;
}
};
void test(){
//当网络连接失败，抛出这个异常即可
//throw HttpException("Http fail", 2);
//当缓存错误
//throw CacheException("Cache error", 3);
//当数据库错误
throw SqlException("Sql error", 4);
}
int main(){
try{
test();
}
//用基类捕捉即可
catch (const Exception& a){
a.what();
}
catch (...){
cout << "unknow exception" << endl;
}
system("pause");
return 0;
}在C++库中也建立了一个异常体系。也给我们提供了一些异常类。我们可以在程序中使用这些标准异常，它们也是以父子类层次结构组织起来的。
说明：
unsigned short test(){
unsigned short a = 0;
unsigned short b = 0;
cin >> a >> b;
if (a + b > 65535 ){
//c++标准库中的异常类
throw overflow_error("overflow");
}
return a + b;
}
int main(){
try{
printf("%d\n", test());
}
//用基类捕捉
catch (const exception& a){
cout << a.what() << endl;
}
catch (...){
cout << "unknow exception" << endl;
}
system("pause");
return 0;
}
异常优点：
总而言之，跟好的返回和描述错误信息，更好定位。针对某些错误，不需要终止程序。
异常缺点
总结：异常的使用利大于弊。异常时面向对象语言处理错误的方式，鼓励使用。