本章主要学习C++中的异常这一方面的知识
注:实际中C语言基本都是使用返回错误码的方式处理错误,部分情况下使用终止程序处理非常严重的错误
异常是一种处理错误的方式,当一个函数发现自己无法处理的错误时就可以抛出异常,让函数的直接或间接的调用者处理这个错误
try
{
// 保护的标识代码
}catch( ExceptionName e1 )
{
// catch 块
}catch( ExceptionName e2 )
{
// catch 块
}catch( ExceptionName eN )
{
// catch 块
}
#include <iostream>
#include <string>
using namespace std;
double Div(int a, int b)
{
if (b == 0)
throw "Div by zero!";//抛出错误
else
return a*1.0 / b;
}
void FileRead()
{
string filename;
cin >> filename;
FILE* fp = fopen(filename.c_str(), "r");
if (fp == nullptr)
{
string message = "fopen error:";
message += filename;
message += "->";
message += strerror(errno);
throw message;
}
char ch;
while ((ch = fgetc(fp)) != EOF)
{
cout << ch;
}
cout << endl;
fclose(fp);
}
void Func()
{
int a, b;
cin >> a >> b;
try {
Div(a, b);
}
catch (const int errno)
{
cout << "errno" << errno << endl;
}
FileRead();
}
int main()
{
while (1)
{
try
{
Func();
}
catch (const char* message)
{
cout << "1->" << message << endl;
}
catch (const string message)
{
cout << "2->" << message << endl;
}
catch (...)
{
cout << "Unknow exception..." << endl;
}
cout << "3" << endl;
}
return 0;
}
沿着调用链查找匹配的catch子句的过程称为栈展开,实际中我们最后都要加一个catch(…)捕获任意类型的异常,否则当有异常没捕获,程序就会直接报错终止
有可能单个的catch不能完全处理一个异常,在进行一些校正处理以后,希望再交给更外层的调用链函数来处理,catch则可以通过重新抛出将异常传递给更上层的函数进行处理
double Division(int a, int b)
{
// 当b == 0时抛出异常
if (b == 0)
{
throw "Division by zero condition!";
}
return (double)a / (double)b;
}
void Func()
{
// 这里可以看到如果发生除0错误抛出异常,另外下面的array没有得到释放
// 所以这里捕获异常后并不处理异常,异常还是交给外面处理
// 这里捕获了再重新抛出去
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;
}
// 这里表示这个函数会抛出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();
// C++11-不会抛出错误
void A() noexcept;
注:没有异常抛出的函数并不是不会报错,在一些操作错误下可能会报错,只是基本上没有啥问题
实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理,因为一个项目中如果大家随意抛异常,那么外层的调用者基本就没办法玩了,所以实际中都会定义一套继承的规范体系。这样大家抛出的都是继承的派生类对象,捕获一个基类就可以了
// 服务器开发中通常使用的异常继承体系
class Exception
{
public:
Exception(int errid, const char* errmsg)
: _errid(errid)
, _errmsg(errmsg)
{}
virtual string what() const
{
return _errmsg;
}
protected:
string _errmsg;
int _errid;
};
class SqlException : public Exception
{
public:
SqlException(int errid, const char* errmsg, const char* sql = "")
:Exception(errid, errmsg)
, _sql(sql)
{}
virtual string what() const
{
string msg = "SqlException:";
msg += _errmsg;
msg += " sql:";
msg += _sql;
return msg;
}
private:
string _sql;
};
class CacheException : public Exception
{
public:
CacheException(int errid, const char* errmsg)
:Exception(errid, errmsg)
{}
virtual string what() const
{
string msg = "CacheException:";
msg += _errmsg;
return msg;
}
};
void f1()
{
// ....
int i;
cin >> i;
if (i == 0)
throw CacheException(1, "数据不存在");
}
void f2()
{
int i;
cin >> i;
if (i == 0)
throw SqlException(1, "数据库查询失败", "select * from t_student");
}
int main()
{
try {
f1();
f2();
}
catch (const Exception& e) // 这里捕获父类对象就可以
{
// 实现一个多态
cout << e.what() << endl;
}
catch (...)
{
cout << "Unkown Exception" << endl;
}
return 0;
}
C++ 提供了一系列标准的异常,定义在中,我们可以在程序中使用这些标准的异常,它们是以父子类层次结构组织起来的
实际中我们可以可以去继承exception类实现自己的异常类。但是实际中很多公司像上面一样自己定义一套异常继承体系。因为C++标准库设计的不够好用
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 << "Unkown Exception" << endl;
}
return 0;
}
注:stl的不同接口对越界的检查要求不一样,vector的at接口严格要求越界就会抛出错误,vector的operator[]接口则是进行随机检查
总结:异常总体而言,利大于弊,所以工程中我们还是鼓励使用异常的。另外OO的语言基本都是用异常处理错误,这也可以看出这是大势所趋