前言
本文讲异常
1. C语言传统的处理错误的方式
C语言处理错误的方式主要是assert断言和错误码errno
2. C++异常概念
C++异常主要是通过三个关键字来实现的
第一个是try，它主要是看你对什么进行抛异常
第二个是throw，主要是抛出异常
第三个就是catch，主要是对throw抛出的异常进行捕获
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 len, time;
cin >> len >> time;
cout << Division(len, time) << endl;
cout<<12<<endl;
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
return 0;
}
看这个程序，第二个参数输入0就会抛异常
throw 抛出异常之后,就会从当前函数开始，有没有捕获，就是检测catch，
如果本个函数函数没有，那就会跳到下一个函数检测catch，直到main函数，注意，这个过程，只是检测有没有catch，不会去运行这些程序
然后就是throw的东西和catch接收的东西，类型应该是一样的，是严格对应的
catch (const string&s)
{
cout << s << endl;
}
就算可以强制类型转换的也不行
所以说捕获到异常，就相当于直接跳到catch了
catch (const char* errmsg)
{
cout << errmsg << endl;
}
cout << 12345 << endl;
然后就是捕获到了异常，就会跳到catch，然后catch后面的程序还是会正常执行的
然后就是抛出了异常，写了try，写了throw就一定要catch
而且try和catch一定是紧挨着的，try后面一定要跟着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 len, time;
cin >> len >> time;
try
{
cout << Division(len, time) << endl;
}
catch (const char* errmsg)
{
cout << 12345 << endl;
cout << errmsg << endl;
}
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
return 0;
}
一次throw只会对应一次catch，只会执行一个catch，而且这个catch肯定是最近的catch，就是按照函数递归的顺序找到的catch
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
catch(int a)
{
cout << a << endl;
}
然后就是一个try后面可以跟着很多个catch，为了防止throw出其他类型，没有接收到
double Division(int a, int b)
{
// 当b == 0时抛出异常
if (b == 0)
throw 11;
else
return ((double)a / (double)b);
}
void Func()
{
int len, time;
cin >> len >> time;
try
{
cout << Division(len, time) << endl;
}
catch (const char* errmsg)
{
cout << 12345 << endl;
cout << errmsg << endl;
}
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
catch(...)
{
cout << "unkown exception" << endl;
}
return 0;
}
然后就是catch的参数类型可以是三个点，这个就表示接受throw返回的任意类型
但这个一般放在后面，因为不知道是什么类型的嘛
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 len, time;
cin >> len >> time;
try
{
cout << Division(len, time) << endl;
}
catch (const char* errmsg)
{
cout << 12345 << endl;
cout << errmsg << endl;
}
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
catch(...)
{
cout << "unkown exception" << endl;
}
return 0;
}
然后就是throw 抛出对象"Division by zero condition!"，是要先对"Division by zero condition!"进行拷贝，拷贝出一个对象，然后对象在赋值给const char* errmsg
3. 抛异常与派生类,基类
可以抛出的派生类对象，
使用基类捕获
// 服务器开发中通常使用的异常继承体系
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 = '张三'");
}
//throw "xxxxxx";
}
void CacheMgr()
{
srand(time(0));
if (rand() % 5 == 0)
{
throw CacheException("权限不足", 100);
}
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();
}
#include<chrono>
#include <thread>
using namespace std;
int main()
{
while (1)
{
this_thread::sleep_for(chrono::seconds(1));
try {
HttpServer();
}
catch (const Exception& e) // 这里捕获父类对象就可以
{
// 多态
cout << e.what() << endl;
}
catch (...)
{
cout << "Unkown Exception" << endl;
}
}
return 0;
}
看这个程序，就是用的基类来接收抛异常，不同的派生类，就会打印出不同的东西
void CacheMgr()
{
if (rand() % 2 == 0)
{
throw CacheException("网络不佳", 100);
}
else if (rand() % 3 == 0)
{
throw CacheException("对方已删除你的好友", 101);
}
throw CacheException("发送成功", 103);
}
void HttpServer()
{
//网络不佳，就重新发送三次
for (int i = 0; i < 4; i++)
{
try
{
CacheMgr();
}
catch (const Exception& e)
{
if (e.GetId() == 100)
{
if (i == 3)
{
cout << "发送失败" << endl;
break;
}
cout << "网络不佳，开始第" << i + 1 << "次发送" << endl;
}
else if(e.GetId() == 101)
{
//break;//break跳出的是catch，所以不用break
throw e;
}
else
{
throw e;
}
}
}
}
#include<chrono>
#include <thread>
using namespace std;
int main()
{
srand(time(0));
int n = 10;
while (1)
{
this_thread::sleep_for(chrono::seconds(1));
try {
HttpServer();
}
catch (const Exception& e)
{
cout << e.what()<< endl;
}
cout << endl;
}
return 0;
}
如上，这个程序就能很好的模拟出我们发送消息的时候的场景
4. 异常的重新抛出
double Division(int a, int b)
{
// 当b == 0时抛出异常
if (b == 0)
{
throw "Division by zero condition!";
}
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;
}
// ...
cout << "delete []" << array << endl;
delete[] array;
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
return 0;
}
这里可以看到如果发生除0错误抛出异常，另外下面的array没有得到释放。
所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再重新抛出去。
这里的意思就是如果抛异常了，先释放空间，在抛异常给外面，因为一个throw只能对应一个catch嘛，在catch里面再写throw，就可以传递给其他的catch了，注意不是还传递给当前的catch哈
catch (const char*arr)
{
cout << "delete []" << array << endl;
delete[] array;
throw arr;
}
还可以这样写，捕获arr，再抛出arr
当然
catch (...)
{
cout << "delete []" << array << endl;
delete[] array;
throw;
}
这样写也是那个意思，捕获arr，再抛出arr，只不过这样写更简便，三个点的意思就相当于auto的意思，万能的接受，再来个空白的throw，就相当于把这个auto的抛出去了
catch (const char* arr)
{
cout << "delete []" << array << endl;
delete[] array;
throw;
}
所以这样写也可以
int* array1 = new int[10];
int* array2 = new int[10];
delete array1;
delete array2;
注意new本身也会抛异常的，我们以前说过的，new也会抛异常
new如果失败了，就会抛异常，array1抛异常还好说，反正开辟失败了没事，array2 还没开始开辟空间
如果array2 抛异常了就不好说了，因为说明array1已经开辟好了，开辟成功了，那么它的空间就不好释放了，因为无法把array1的地址抛给throw
，所以后面写的delete array1;就没有什么用了，而且还真的不好处理,
所以这个时候就可以用智能指针去处理了，这个就很好处理
5 异常的利与弊
这里有要说明的几点
第一就是不要再构造和析构函数中抛异常，因为可能会导致构造和析构不完整
函数的后面接throw()，表示函数不抛异常。
C++11 中新增的noexcept，表示不会抛异常
函数后面加上noexcept也表示不会抛异常
C++标准库中有很多throw的接口，有的越界，有的开辟空间失败，反正有很多很多，因为C++标准库的很多函数都加了抛异常的，所以要有对应的throw接口才行
// 这里表示这个函数只会抛出bad_alloc的异常
void* operator new (std::size_t size) throw (std::bad_alloc);
比如这个bad_alloc就是一种throw类型
// 这里表示这个函数不会抛出异常
void* operator delete (std::size_t size, void* ptr) throw();
// C++11 中新增的noexcept，表示不会抛异常
thread() noexcept;
thread (thread&& x) noexcept;
总结
下一节讲智能指针
1787
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
