《一》C语言常用的处理错误方式
一般就是 “assert”等，使用起来比较难受，就比如是在我们用C语言写二叉树，或者链表的时候，就是常用的assert来断言，这样程序出错就回报错，但是直接就会终止程序，不太好用。
实际中C语言基本都是返回错误码的方式，来处理错误，部分情况使用终止程序处理出现严重的代码。
《二》c++的异常概念
异常是一种解决错误的方式，当一个函数无法处理现在问题，就可以抛出异常，给使用函数的直接或者间接者来处理这个错误。
- throw : 当程序出现问题的时候，程序会抛出一个异常，这是通过throw关键字来解决的。
- catch : 就是你想在任何一个地方找到异常的问题，那么就可以捕获异常，那么就可以用catch关键字，catch关键字可以多个一起使用。
- try ： try关键的使用，就像咱们之前C语言学习的 “switch ,cash ”的使用方法是一样的。try块中的代码标识将被激活特定的异常，它的后面通常跟一个或者多个catch。
大概就像下面的图片使用一样；我们来看一下：
在这里要记得这是在函数里面实现里面。
《二》异常的的使用，抛出和捕获
1. 异常是由抛出对象产生的，该对象会的类型会调用什么样的catch的处理段。
void func1()
{
//throw 10;//调用func1了，然后直接输出了。
//throw 10.12909;//捕获最后的异常
}
void func2()
{
//string str("error");
//throw str;
try
{
string str("error");
throw str;
}
catch (const string& str)
{
cout << str << endl;
}
}
int main()
{
try
{
func1();
func2();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
catch (int i)//捕获整形异常
{
cout << i << endl;
}
catch (const string& str)//捕获string异常
{
cout << str << endl;
}
catch(...) //捕获任意异常，知道发生异常，但是不知道发生什么异常。
{
cout << "未知异常" << endl;
}
cout << "end" << endl;
return 0;
}
当func1没有执行的时候，执行func2 ，那么就会寻找与func2有关的catch代码段，以及后面执行的语句，这就是第一天的解读代码。
3. catch(…)会处理任何异常，但是不知道异常的错误是什么，一般是最后一道防线
catch(...) //捕获任意异常，知道发生异常，但是不知道发生什么异常。
{
cout << "未知异常" << endl;
}
cout << "end" << endl;
回答：这句含义，就按照上面的代码，就可以解决出来，
4. 被选中的处理代码，会选择抛出异常最近的那一个。
void func2()
{
try
{
string str(“error”);
throw str;
}
catch (const string& str)
{
cout << str <<LINE<< endl;
}
}
int main()
{
try
{
func1();
func2();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
catch (int i)//捕获整形异常
{
cout << i << endl;
}
catch (const string& str)//捕获string异常
{
cout << str << LINE<< endl;
}
catch(…) //捕获任意异常，知道发生异常，但是不知道发生什么异常。
{
cout << “未知异常” << endl;
}
cout << “end” << endl;
return 0;
}
这段代码 和前面的一样，但是就是在调用func2的时候，不一样，我们可以看到，在主函数和func2中，都有一个捕获异常的代码，两者还是一样的，但是优先使用的是函数里面的，所以，它是按照最近的方式来调用的，
5. 当抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似于函数的传值返回）
《三》异常的重新抛出
double Division(int a, int b)
{
// 当b == 0时抛出异常
if (b == 0)
throw "Division by zero condition!";
else
return ((double)a / (double)b);
}
void Func()
{
//如果这里增加这个的时候。
int* p = new int[10];
int len, time;
cin >> len >> time;
cout << Division(len, time) << endl;
delete[] p; //这里当分母为偶数的时候，那么就不能被有效的释放了，所以这里上面要自己截获异常。
cout << p << endl;
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
catch (...)
{
cout << "unkown exception" << endl;
}
return 0;
}
当我们使用这一段的代码的时候，通过程序的执行，我们可以看到，当分母不为0的时候，创建，并且空间也释放了，但是当分母为0的时候，创建了，但是空间没有释放 ，下面我们拿执行程序图来看一下，
那么我们怎么解决这样的问题，下面，我们继续往下面看。
首先，我们先用第一种方法，异常处理来解决这样的问题，下面我们来看一下代码。
void Func()
{
//如果这里增加这个的时候。
int* p = new int[10]; //异常安全问题
try{
int len, time;
cin >> len >> time;
cout << Division(len, time) << endl;
}
//第一种解决
catch (const char* errmsg)
{
delete[] p; //这里当分母为偶数的时候，那么就不能被有效的释放了，所以这里上面要自己截获异常。
cout << p << endl;
throw errmsg;
}
}
我们现在再看一下执行程序，
与上面的作比较，我们可以看出来，在这里，我们不管分母为0还是不为0，执行下来，空间都可以释放。既然说了上面是第一种方法，那么，肯定下面还会有第二种方法，我们接下来，再看看，第二种解决方法。
catch (...)
{
delete[] p;
cout << p << endl;
throw;
}
delete[] p; //如果只是用上面的话，只释放，但是没有抛出异常，这里问题很大，不能告诉外面处理的人，
cout << p << endl;
然后，我们看一下执行程序的图片，
由执行程序可以看出来，当分母为0的时候，占用的空间还是被释放了，与第一种的实现的结果，是一样的，都是当分母为0的时候，占用空间还是被释放。
《四》异常安全
- 构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化。
- 析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内存泄漏、句柄未关闭等)。
- C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题。
《五》异常规范
- 异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数的后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。
- 函数的后面接throw()，表示函数不抛异常。
- 若无异常接口声明，则此函数可以抛掷任何类型的异常。
// 这里表示这个函数会抛出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();
《六》自定义异常体系
在我们的日常中，不管是我们自己还是企业，很大的一部分都是自己定义一套异常体系来进行异常管理。那么，我们该怎么样实现呢？我们现看下面的一段，自定义异常代码。
#include<iostream>
#include<string>
#include<fstream>
using namespace std;
class WChatException
{
public:
WChatException(int errid , const string& errmsg)
:_errid(errid)
, _errmsg(errmsg)
{}
virtual ~WChatException()
{}
//virtual string what() = 0;
virtual void log() const = 0; //这里的const没有写
protected:
int _errid;
string _errmsg;
//string _file;
//string _line;
};
class WChatPayException : public WChatException
{
public:
WChatPayException(int errid, const string& errmsg , const char* file = "payerrorlog.log")
:WChatException(errid, errmsg)
, _file(file)
{}
virtual ~WChatPayException()
{}
/*virtual string what()
{}*/
virtual void log() const
{
ofstream ofs(_file);
ofs << _errmsg << endl;
ofs << _errid << endl;
}
private:
const char* _file;
};
class WChatFrindsException : public WChatException
{
public:
WChatFrindsException(int errid, const string& errmsg, const char* file = "frindseerrorlog.log")
:WChatException(errid, errmsg)
, _file(file)
{}
virtual ~WChatFrindsException()
{}
/*virtual string what()
{}*/
virtual void log() const
{
ofstream ofs(_file);
ofs << _errmsg << endl;
ofs << _errid << endl;
}
private:
const char* _file;
};
void func()
{
for (size_t i = 0; i < 10; i++)
{
if (rand() % 2 == 0)
{
WChatPayException e(1, "余额不足");
throw e;
}
if (rand() % 3 == 0)
{
WChatFrindsException e(1, "网络异常");
throw e;
}
}
}
int main()
{
try
{
func();
}
catch (const WChatException& e)
{
e.log();
}
return 0;
}
通过这段代码，我们来理解，下面，我们再看一下，执行程序，哪里我们不能看到，所以，我们在当前的文件夹里面，来看一下程序，执行过后的代码。
通过这两张图片。我们就可以看到，我们自己定义的异常，并且来管理异常，那么这样，我们就可以实现对很多情况下面，来对程序实现可控性。
《七》异常的优缺点
( 7.1 ) 异常的优点:
- 异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的bug。
- 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们得层层返回错误，最外层才能拿到错误
3**.很多测试框架都使用异常**，这样能更好的使用单元测试等进行白盒的测试。 - 部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如T&
operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。
(7.2)异常的缺点：
- 异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会导致我们跟踪调试时以及分析程序时，比较困难。
- 异常会有一些性能的开销。当然在现代硬件速度很快的情况下，这个影响基本忽略不计。
- C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常安全问题。这个需要使用RAII来处理资源的管理问题。学习成本较高。
- C++标准库的异常体系定义得不好，导致大家各自定义各自的异常体系，非常的混乱。
- 异常尽量规范使用，否则后果不堪设想，随意抛异常。
那么接下来我们总结一下 ： 异常既有有点，也有缺点，但是利大于弊，我们更加提倡使用异常，可以解决我们很多的问题，这也是一种流行的方向。
扫一扫
2375
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
