C++ 异常
C++ 异常
在C语言的世界中，对错误的处理总是围绕着两种方法：一是使用整型的返回值标识错误；二是使用errno宏（可以简单的理解为一个全局整型变量）去记录错误。当然C++中仍然是可以用这两种方法的。
这两种方法最大的缺陷就是会出现不一致问题。例如有些函数返回1表示成功，返回0表示出错；而有些函数返回0表示成功，返回非0表示出错。
还有一个缺点就是函数的返回值只有一个，你通过函数的返回值表示错误代码，那么函数就不能返回其他的值。当然，你也可以通过指针或者C++的引用来返回另外的值，但是这样可能会令你的程序略微晦涩难懂。
c++异常机制相比C语言异常处理的优势
- 函数的返回值可以忽略，但异常不可忽略。如果程序出现异常，但是没有被捕获，程序就会终止，这多少会促使程序员开发出来的程序更健壮一点。而如果使用C语言的error宏或者函数返回值，调用者都有可能忘记检查，从而没有对错误进行处理，结果造成程序莫名其面的终止或出现错误的结果。
- 整型返回值没有任何语义信息。而异常却包含语义信息，有时你从类名就能够体现出来。
- 整型返回值缺乏相关的上下文信息。异常作为一个类，可以拥有自己的成员，这些成员就可以传递足够的信息。
- 异常处理可以在调用跳级。这是一个代码编写时的问题：假设在有多个函数的调用栈中出现了某个错误，使用整型返回码要求你在每一级函数中都要进行处理。而使用异常处理的栈展开机制，只需要在一处进行处理就可以了，不需要每级函数都处理。
//如果判断返回值，那么返回值是错误码还是结果？
//如果不判断返回值，那么b==0时候，程序结果已经不正确
//A写的代码
int A_MyDivide(int a,int b){
if (b == 0){
return -1;
}
return a / b;
}
//B写的代码
int B_MyDivide(int a,int b){
int ba = a + 100;
int bb = b;
int ret = A_MyDivide(ba, bb); //由于B没有处理异常，导致B结果运算错误
return ret;
}
//C写的代码
int C_MyDivide(){
int a = 10;
int b = 0;
int ret = B_MyDivide(a, b); //更严重的是，由于B没有继续抛出异常，导致C的代码没有办法捕获异常
if (ret == -1){
return -1;
}
else{
return ret;
}
}
//所以,我们希望：
//1.异常应该捕获，如果你捕获，可以，那么异常必须继续抛给上层函数,你不处理，不代表你的上层不处理
//2.这个例子，异常没有捕获的结果就是运行结果错的一塌糊涂，结果未知，未知的结果程序没有必要执行下去
异常严格类型匹配
异常机制和函数机制互不干涉,但是捕捉方式是通过严格类型匹配。
class MyException
{
public:
void printError()
{
cout << "我自己的异常" << endl;
}
};
class Person
{
public:
Person()
{
cout << "Person的默认构造函数调用" << endl;
}
~Person()
{
cout << "Person的析构函数调用" << endl;
}
};
int myDivision(int a , int b)
{
if ( b == 0)
{
//return -1;
//throw 1; //抛出int类型的异常
//throw 'a'; //抛出char类型的异常
//throw 3.14; //抛出double类型的异常
/*string str = "abc";
throw str;*/
//从try代码块开始，到throw抛出异常之前，所有栈上的数据都会被释放掉，
//释放的顺序和创建顺序相反的，这个过程我们称为栈解旋
Person p1;
Person p2;
throw MyException(); //抛出 MyException的匿名对象
}
return a / b;
}
void test01()
{
int a = 10;
int b = 0;
//C语言处理异常 有缺陷：返回值不统一，返回值只有一个，无法区分是结果还是异常
//int ret =myDivision(a, b);
//if ( ret == -1)
//{
// cout << "异常" << endl;
//}
try
{
myDivision(a, b);
}
catch (int)
{
cout << "int类型异常捕获" << endl;
}
catch (char)
{
cout << "char类型异常捕获" << endl;
}
catch (double)
{
//捕获到了异常，但是不想处理，继续向上抛出这个异常
//异常必须有函数进行处理，如果没有任何处理，程序自动调用 terminate 函数，让程序中断
throw;
cout << "double类型异常捕获" << endl;
}
catch (MyException e)
{
e.printError();
}
catch (...)
{
cout << "其他类型异常捕获" << endl;
}
}
int main(){
try
{
test01();
}
catch (double)
{
cout << "double函数中 double类型异常捕获" << endl;
}
catch (...)
{
cout << "main函数中 其他类型异常捕获" << endl;
}
system("pause");
return EXIT_SUCCESS;
}
栈解旋(unwinding)
异常被抛出后，从进入try块起，到异常被抛掷前，这期间在栈上构造的所有对象，都会被自动析构。析构的顺序与构造的顺序相反，这一过程称为栈的解旋(unwinding).
int myDivision(int a , int b)
{
if ( b == 0)
{
//return -1;
//throw 1; //抛出int类型的异常
//throw 'a'; //抛出char类型的异常
//throw 3.14; //抛出double类型的异常
/*string str = "abc";
throw str;*/
//从try代码块开始，到throw抛出异常之前，所有栈上的数据都会被释放掉，
//释放的顺序和创建顺序相反的，这个过程我们称为栈解旋
Person p1;
Person p2;
throw MyException(); //抛出 MyException的匿名对象
}
return a / b;
}
异常接口声明
- 为了加强程序的可读性，可以在函数声明中列出可能抛出异常的所有类型，例如：
void func() throw(A,B,C);这个函数func能够且只能抛出类型A,B,C及其子类型的异常。 - 如果在函数声明中没有包含异常接口声明，则此函数可以抛任何类型的异常，例如:
void func() - 一个不抛任何类型异常的函数可声明为:
void func() throw() - 如果一个函数抛出了它的异常接口声明所不允许抛出的异常,
unexcepted函数会被调用，该函数默认行为调用terminate函数中断程序。
//可抛出所有类型异常
void TestFunction01(){
throw 10;
}
//只能抛出int char char*类型异常
void TestFunction02() throw(int,char,char*){
string exception = "error!";
throw exception;
}
//不能抛出任何类型异常
void TestFunction03() throw(){
throw 10;
}
int main(){
try{
//TestFunction01();
//TestFunction02();
//TestFunction03();
}
catch (...){
cout << "捕获异常!" << endl;
}
system("pause");
return EXIT_SUCCESS;
}
异常变量生命周期
class MyException
{
public:
MyException()
{
cout << "MyException默认构造函数调用" << endl;
}
MyException(const MyException& e)
{
cout << "MyException拷贝构造函数调用" << endl;
}
~MyException()
{
cout << "MyException析构函数调用" << endl;
}
};
void doWork()
{
throw new MyException();
}
void test01()
{
try
{
doWork();
}
//抛出的是 throw MyException(); catch (MyException e) 调用拷贝构造函数 效率低
//抛出的是 throw MyException(); catch (MyException &e) 只调用默认构造函数 效率高 推荐
//抛出的是 new MyException(); catch (MyException *e) 只调用默认构造函数 自己要管理释放
catch (MyException* e)
{
cout << "自定义异常捕获" << endl;
delete e;
}
}
-
抛出的是
throw MyException(); catch (MyException e),catch (MyException e)使用的是值传递，调用拷贝构造函数 效率低
-
抛出的是
throw MyException(); catch (MyException &e)只调用默认构造函数 效率高 推荐
-
抛出的是
new MyException(); catch (MyException *e)只调用默认构造函数，但在堆区创建的对象需要自己要管理释放
void doWork()
{
throw new MyException();
}
void test01()
{
try
{
doWork();
}
catch (MyException* e)
{
cout << "自定义异常捕获" << endl;
delete e;
}
}
异常的多态使用
//异常基类
class BaseException{
public:
//纯虚函数
virtual void printError(){};
};
//空指针异常
class NullPointerException : public BaseException{
public:
virtual void printError(){
cout << "空指针异常!" << endl;
}
};
//越界异常
class OutOfRangeException : public BaseException{
public:
virtual void printError(){
cout << "越界异常!" << endl;
}
};
void doWork(){
throw NullPointerException();
}
void test()
{
try{
doWork();
}
//使用父类引用指向子类对象
catch (BaseException& ex){
ex.printError();
}
}
系统标准异常
标准库
标准库中也提供了很多的异常类，它们是通过类继承组织起来的。异常类继承层级结构图如下：
每个类所在的头文件在图下方标识出来。
标准异常类的成员：
① 在上述继承体系中，每个类都有提供了构造函数、复制构造函数、和赋值操作符重载。
② logic_error类及其子类、runtime_error类及其子类，它们的构造函数是接受一个string类型的形式参数，用于异常信息的描述
③ 所有的异常类都有一个what()方法，返回const char*类型（C风格字符串）的值，描述异常信息。
标准异常类的具体描述：
| 异常名称 | 描述 |
|---|---|
| exception | 所有标准异常类的父类 |
| bad_alloc | 当operator new and operator new[]，请求分配内存失败时 |
| bad_exception | 这是个特殊的异常，如果函数的异常抛出列表里声明了bad_exception异常，当函数内部抛出了异常抛出列表中没有的异常，这是调用的unexpected函数中若抛出异常，不论什么类型，都会被替换为bad_exception类型 |
| bad_typeid | 使用typeid操作符，操作一个NULL指针，而该指针是带有虚函数的类，这时抛出bad_typeid异常 |
| bad_cast | 使用dynamic_cast转换引用失败的时候 |
| ios_base::failure | io操作过程出现错误 |
| logic_error | 逻辑错误，可以在运行前检测的错误 |
| runtime_error | 运行时错误，仅在运行时才可以检测的错误 |
logic_error的子类：
| 异常名称 | 描述 |
|---|---|
| length_error | 试图生成一个超出该类型最大长度的对象时，例如vector的resize操作 |
| domain_error | 参数的值域错误，主要用在数学函数中。例如使用一个负值调用只能操作非负数的函数 |
| out_of_range | 超出有效范围 |
| invalid_argument | 参数不合适。在标准库中，当利用string对象构造bitset时，而string中的字符不是’0’或’1’的时候，抛出该异常 |
runtime_error的子类：
| 异常名称 | 描述 |
|---|---|
| range_error | 计算结果超出了有意义的值域范围 |
| overflow_error | 算术计算上溢 |
| underflow_error | 算术计算下溢 |
| invalid_argument | 参数不合适。在标准库中，当利用string对象构造bitset时，而string中的字符不是’0’或’1’的时候，抛出该异常 |
标准异常使用
- 引入头文件
#include <stdexcept> - 抛出越界异常
throw out_of_range(“…”) - 获取错误信息
catch( exception & e ) e.what();
#include <stdexcept> // std 标准 except 异常
class Person
{
public:
Person(int age)
{
if (age < 0 || age > 150)
{
throw out_of_range("年龄必须在 0 ~ 150之间");
//throw length_error("年龄必须在 0 ~ 150之间");
}
else
{
this->m_Age = age;
}
}
int m_Age;
};
void test()
{
try
{
Person p(151);
}
//catch ( out_of_range &e)
catch (exception &e)
{
cout << e.what() << endl;
}
}
自己的异常类
如何编写自己的异常类？
- 建议自己的异常类要继承标准异常类。因为
C++中可以抛出任何类型的异常，所以我们的异常类可以不继承自标准异常，但是这样可能会导致程序混乱，尤其是当我们多人协同开发时。 - 当继承标准异常类时，应该重载父类的
what函数和虚析构函数。 - 因为栈展开的过程中，要复制异常类型，那么要根据你在类中添加的成员考虑是否提供自己的复制构造函数。
class MyOutOfRangeException:public exception
{
public:
MyOutOfRangeException( const char * str)
{
//const char * 可以隐式类型转换为 string 反之不可以
this->m_errorInfo = str;
}
MyOutOfRangeException(string str)
{
this->m_errorInfo = str;
}
// 最后一个为const为常函数
virtual const char * what() const
{
//将string 转为 const char *
return m_errorInfo.c_str();
}
string m_errorInfo;
};
class Person
{
public:
Person(int age)
{
if (age < 0 || age > 150)
{
//创建有参匿名对象 string( "年龄必须在0到150之间")
//throw MyOutOfRangeException("年龄必须在0到150之间"); >> char * str类型
throw MyOutOfRangeException( string( "年龄必须在0到150之间"));
}
else
{
this->m_Age = age;
}
}
int m_Age;
};
void test()
{
try
{
Person p(1000);
}
catch (exception & e)
{
cout << e.what() << endl;
}
}
总结：
- 编写
myOutofRange继承·Exception类 - 重写
virtual const char * what() const（） - 将
sting转为const char *使用.c_str() const char *可以隐式类型转换为string反之不可以- 测试，利用多态打印出错误提示信息
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
