1.C语言传统的处理错误的方式：
1.终止程序，如常见的assert，缺陷：用户难以接受 。 除0错误，内存错误时程序直接退出
2.返回错误码，缺陷。 需要程序员自己去查找对应的错误。如程序的很多库的接口函数都是通过把错误码放到errono中，表示错误。
2.C++对异常的处理
异常是一种处理错误的方法。当一个函数发现自己有无法处理的错误就开始抛异常，让函数直接或者间接的调用者处理这个函数。
- throw:当问题出现异常的时候，程序会抛出一个异常。这是通过使用throw关键字来完成的
- catch：在想要处理问题的地方，通过异常处理程序捕获异常。catch关键字通过捕获异常，可以使用多个catch进行捕获
- try：try块中的代码将被激活的特定抛异常，紧跟着一个或者多个catch。
如果一个块中抛出一个异常，捕获异常的方法会使用try和catch关键字。try位置存放可能出现的异常，被称为保护代码。语法如下
try
{
Func();//保护的标识代码
}
catch (const char* errmsg)
{
cout << errmsg << endl;//catch块
}
catch (...)
{
cout << "unknow exception" << endl;//catch块
}
3.异常的使用
3.1异常的抛出和捕获
- 1.异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码
- 2.被选中的处理代码是调用链中与该对象类型匹配且离抛出异常最近的哪一个
- 3.抛出异常后，会生成一个异常的拷贝，因为抛出的异常是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。
- 4.catch(…)可以捕获任何异常，但是不知道是什么异常
- 5.实际中抛出和捕获的匹配的原则有个例外，b并不都是类型匹配，可以抛出派生类的异常，使用基类捕获。
在函数调用链中异常栈展开匹配原则
- 代码实现：
double Division(int a, int b)
{
if (b == 0)
throw "Division by zero condition!";
else
return ((double)a / (double)b);
}
void Func()
{
int len, time;
cin >> len >> time;
cout << Division(len, time) << endl;
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
catch (...)
{
cout << "unknow exception" << endl;
}
system("pause");
return 0;
}
结果：抛异常
3.2异常的重新抛出
- 有时候单个的catch不能完全处理一个抛出异常，在进行一些校对处理之后，再把异常抛给更外层的调用链函数来处理。
- 代码实现
double Division(int a, int b)
{
if (b == 0)
throw "Division by zero condition!";
else
return ((double)a / (double)b);
}
void Func()
{
int* array = new int[10];
int len, time;
cin >> len >> time;
cout << Division(len, time) << endl;
cout << "delete[] " << array << endl;
delete[] array;
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
system("pause");
}
- 运行结果：
我们发现这里只抛了异常并没有释放内存，因此我们应改成下面的代码:
double Division(int a, int b)
{
if (b == 0)
throw "Division by zero condition!";
else
return ((double)a / (double)b);
}
void Func()
{
int* array = new int[10];
//这里捕获了异常，并将异常交给外面处理，同时释放了空间，不会造成内存泄露
try
{
int len, time;
cin >> len >> time;
cout << Division(len, time) << endl;
}
catch (...)
{
cout << "delete[]" << array << endl;
delete[] array;
throw;
}
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
system("pause");
}
运行结果：
异常规范
- 构造函数完成对象的构造和初始化，最好不要在构造函数抛异常，否则可能导致对象不完成或者没有完全初始化
- 析构函数主要完成资源的清理，最好不要在析构函数处抛异常，否则可能导致内存泄漏。
- C++异常经常会导致资源泄露的问题，比如new,lock,malloc等没有合适的匹配到delete,unlock,free导致系统崩溃。明天我们学到的智能指针可以解决该问题。
异常规范
- 异常格式说明的目的是为了让函数使用者知道函数可能抛出的异常有哪些可以在函数的后边接throw，列出函数可能抛掷出的所有异常类型。
- 函数后面接throw(),表示函数不抛异常
- 若无异常接口生命，则函数可以抛掷任何类型的异常。
//表示在这个函数会抛出A/B/C中任意类型的异常
void fun() throw(A, B, C);
//这里表示这个函数只会抛出bad_alloc的异常
void operator* new(size_t size)throw(bad_alloc());
//这里表示函数不会抛出异常
void* operator new(size_t size, void* ptr) throw();
4.自定义类型函数声明：
很多公司都会自定义自己的异常体系管理。大家抛出的异常都是继承的派生类，捕获一个基类就可以了。
5.C++提供了一系列的标准异常，定义在std::exception中，我们可以在系统中标准化这些异常。
#include<vector>
int main()
{
try
{
vector<int> v(10, 5);
v.reserve(1000000000);
v.at(10) = 100;
}
catch (const exception& e)//捕获父类就好
{
cout << e.what() << endl;
}
catch (...)
{
cout << "Unknown Exception" << endl;
}
system("pause");
}
6.异常的优缺点
c++异常的优缺点：
1.异常定义好了，相比错误码的方式可以清晰准确的展示出错误的信息，甚至可以包含堆栈中调用的信息，这样可以更好地找到BUG。
2.返回错误码的传统方式有个很大的问题，在函数调用链中，深层的函数返回了错误，那么我们必须层层返回错误，在最外层才能找到错误。
3.很多第三方库都包含异常。
4.很多测试框架都是用异常。
5.部分函数异常更好处理。如构造函数没有返回值，不方便使用错误代码。
C++的缺点
1.异常会导致程序的执行流乱跳，导致非常的混乱，并且是边运行边乱跳，导致我们很难分析代码。
2.异常会有一些性能的开销。但是由于现在硬件的开发，影响可以忽略不计
3.C++没有垃圾回收，资源要自己回收，因此处理异常的时候会出现内存泄漏等问题。可以用内存指针解决。
4.C++标准库异常的体系没有定义好
5.异常尽量规范使用。异常规范有两点：1.抛出异常类型都继承自一个基类。 2.函数是否抛异常，抛什么异常，使用上文的func（） throw（）；的方式规范化。
总结
总体来说，还是鼓励异常地使用的，利大于弊。OO语言都是用异常处理错误，这也是大势所趋。