行业资讯

C++语言（13）——C++异常处理

发布时间：2020-06-24 19:52:42 作者：三九感冒灵
来源：网络 阅读：6667

1、C语言异常处理

1.1、异常的概念

异常：程序在运行过程中可能产生异常(是程序运行时可预料的执行分支)，如：运行时除0的情况，需要打开的外部文件不存在的情况，数组访问越界的情况...
Bug：bug是程序中的错误，是不可被预期运行方式，如：野指针、堆内存结束后未释放、选择排序无法处理长度为0的数组...

1.2、C语言的异常处理

1.2.1经典方法：

if(判断是否产生异常)
{
//正常代码逻辑
}
else
{
//异常代码逻辑
}

#include <iostream>
#include <string>

using namespace std;

double divide(double a, double b, int* valid)
{
    const double delta = 0.000000000000001;  //一般不要拿浮点数和0直接做比较
    double ret = 0;

    if( !((-delta < b) && (b < delta)) )
    {
        ret = a / b;

        *valid = 1;
    }
    else
    {
        *valid = 0;
    }

    return ret;
}

int main(int argc, char *argv[])
{   
    int valid = 0;
    double r = divide(1, 0, &valid);

    if( valid )
    {
        cout << "r = " << r << endl;
    }
    else
    {
        cout << "Divided by zero..." << endl;
    }

    return 0;
}

1.2.2.setjmp()和longjmp()

int setjmp(jmp_buf env)
将当前上下文保存在jmp_buf结构体中
void longjmp(jmp_buf env, int val)
从jmp_buf结构体中恢复setjmp()保存的上下文
最终从setjmp函数调用点返回，返回值为val

#include <iostream>
#include <string>
#include <csetjmp>

using namespace std;
/**缺陷：setjmp()和longjmp()的引入必然涉及到全局变量，暴力跳转导致代码可读性降低***/

static jmp_buf env;     //定义全局变量

double divide(double a, double b)
{
    const double delta = 0.000000000000001;     //一般不要拿浮点数和0直接做比较
    double ret = 0;

    if( !((-delta < b) && (b < delta)) )
    {
        ret = a / b;
    }
    else
    {
        longjmp(env, 1);
    }

    return ret;
}

int main(int argc, char *argv[])
{   
    if( setjmp(env) == 0 )
    {
        double r = divide(1, 1);

        cout << "r = " << r << endl;
    }
    else
    {
        cout << "Divided by zero..." << endl;
    }

    return 0;
}

缺陷：setjmp()和longjmp()的引入必然涉及到全局变量，暴力跳转导致代码可读性降低

2、C++中的异常处理(上)

2.1 try、catch、throw

C++内置了异常处理的语法元素try、catch、throw
--try语句处理正常的代码逻辑
--catch语句处理异常的情况
--C++通过throw语句抛出异常信息
try语句中的异常由对应的catch语句处理
函数在运行时抛出(throw)一个异常到函数调用的地方(try语句内部)，try语句就会将异常交给对应的catch语句去处理

#include <iostream>
#include <string>

using namespace std;

/**函数在运行时抛出(throw)一个异常到函数调用的地方(try语句内部)，try语句就会将异常交给对应的catch语句去处理**/
double divide(double a, double b)
{
    const double delta = 0.000000000000001;
    double ret = 0;

    if( !((-delta < b) && (b < delta)) )
    {
        ret = a / b;
    }
    else
    {
        throw 0;
    }

    return ret;
}

int main(int argc, char *argv[])
{    
    try
    {
        double r = divide(1, 0);

        cout << "r = " << r << endl;
    }
    catch(...)
    {
        cout << "Divided by zero..." << endl;
    }

    return 0;
}

2.2 C++异常处理分析

--throw抛出的异常必须被catch处理
当前函数能够处理异常，程序继续往下执行
当前函数无法处理异常，则函数停止执行，并返回(未被处理的异常会顺着函数调用栈向上传播，直到被处理为止，否则程序将停止执行)

2.3自定义具体的异常类型

--不同的异常由不同的catch语句负责处理
--catch(...)用于处理所有类型的异常(只能被放在最后面)

#include <iostream>
#include <string>

using namespace std;

/**异常抛出后，至上而下将严格的匹配每一个catch语句处理的类型，不进行任何类型的转换**/
void Demo1()
{
    try
    {   
        throw 'c';
    }
    catch(char c)
    {
        cout << "catch(char c)" << endl;
    }
    catch(short c)
    {
        cout << "catch(short c)" << endl;
    }
    catch(double c)
    {
        cout << "catch(double c)" << endl;
    }
    catch(...)
    {
        cout << "catch(...)" << endl;
    }
}

void Demo2()
{
    throw string("D.T.Software");
}

int main(int argc, char *argv[])
{    
    Demo1();

    try
    {
        Demo2();
    }
    catch(char* s)
    {
        cout << "catch(char *s)" << endl;
    }
    catch(const char* cs)
    {
        cout << "catch(const char *cs)" << endl;
    }
    catch(string ss)
    {
        cout << "catch(string ss)" << endl;
    }

    return 0;
}

注意：任何异常都只能被捕获(catch)一次，异常抛出后，捕获时至上而下将严格的匹配每一个catch语句处理的类型，不进行任何类型的转换

3、C++中的异常处理(下)

3.1、catch重新解释

catch中捕获的异常可以被重新解释抛出，catch抛出的异常需要外层的try...catch...捕获
为什么要重新抛出异常？
实际工程中我们可以对第三方库中抛出的异常进行捕获、重新解释(统一异常类型，方便代码问题定位)，然后再抛出

#include <iostream>
#include <string>

using namespace std;

void Demo()
{
    try
    {
        try
        {
            throw 'c';
        }
        catch(int i)
        {
            cout << "Inner: catch(int i)" << endl;
            throw i;
        }
        catch(...)
        {
            cout << "Inner: catch(...)" << endl;
            throw;
        }
    }
    catch(...)
    {
        cout << "Outer: catch(...)" << endl;
    }
}

/*
    假设： 当前的函数是第三方库中的函数，因此，我们无法修改源代码

    函数名： void func(int i)
    抛出异常的类型： int
                        -1 ==》 参数异常
                        -2 ==》 运行异常
                        -3 ==》 超时异常
*/
void func(int i)
{
    if( i < 0 )
    {
        throw -1;
    }

    if( i > 100 )
    {
        throw -2;
    }

    if( i == 11 )
    {
        throw -3;
    }

    cout << "Run func..." << endl;
}

void MyFunc(int i)  //调用第三方库函数，捕获并重新解释异常，然后抛出
{
    try
    {
        func(i);
    }
    catch(int i)
    {
        switch(i)
        {
            case -1:
                throw "Invalid Parameter";      //捕获异常并重新解释并抛出
                break;
            case -2:
                throw "Runtime Exception";
                break;
            case -3:
                throw "Timeout Exception";
                break;
        }
    }
}

int main(int argc, char *argv[])
{
    Demo();

    try
    {
        MyFunc(11);
    }
    catch(const char* cs)
    {
        cout << "Exception Info: " << cs << endl;
    }

    return 0;
}

注意：
(1)异常的类型可以是自定义类类型，对于类类型异常的匹配依旧是至上而下、严格匹配
(2)赋值兼容原则在异常匹配中依然适用，一般而言
--匹配子类异常的catch放在上部
--匹配父类异常的catch放在下部

#include <iostream>
#include <string>

using namespace std;

class Base
{
};
//异常的类型可以是自定义类类型
class Exception : public Base
{
    int m_id;
    string m_desc;
public:
    Exception(int id, string desc)
    {
        m_id = id;
        m_desc = desc;
    }

    int id() const
    {
        return m_id;
    }

    string description() const
    {
        return m_desc;
    }
};

/*
    假设： 当前的函数式第三方库中的函数，因此，我们无法修改源代码

    函数名： void func(int i)
    抛出异常的类型： int
                        -1 ==》 参数异常
                        -2 ==》 运行异常
                        -3 ==》 超时异常
*/
void func(int i)
{
    if( i < 0 )
    {
        throw -1;
    }

    if( i > 100 )
    {
        throw -2;
    }

    if( i == 11 )
    {
        throw -3;
    }

    cout << "Run func..." << endl;
}

void MyFunc(int i)
{
    try
    {
        func(i);
    }
    catch(int i)
    {
        switch(i)
        {
            case -1:
                throw Exception(-1, "Invalid Parameter");
                break;
            case -2:
                throw Exception(-2, "Runtime Exception");
                break;
            case -3:
                throw Exception(-3, "Timeout Exception");
                break;
        }
    }
}

int main(int argc, char *argv[])
{
    try
    {
        MyFunc(11);
    }

    //在定义catch语句块时推荐使用引用作为参数(防止拷贝构造)
    // 赋值兼容原则在异常匹配中依然适用，一般而言
    catch(const Exception& e)   // 匹配子类异常的catch放在上部
    {
        cout << "Exception Info: " << endl;
        cout << "   ID: " << e.id() << endl;
        cout << "   Description: " << e.description() << endl;
    }
    catch(const Base& e)        // 匹配父类异常的catch放在下部
    {
        cout << "catch(const Base& e)" << endl;
    }

    return 0;
}

3.2工程建议：

在工程中会定义一系列的异常类，每个类代表工程中可能出现的一种异常类型
代码复用时可能需要重新解释不同的异常类
在定义catch语句块时推荐使用引用作为参数(防止拷贝构造)

3.3、标准库异常类族

(1)C++标准库中提供了实用异常类族，都是从exception类派生的，主要有两个分支
--logic_error(常用于程序中可避免的逻辑错误)
--runtime_error(常用于程序中无法避免的恶性错误)
标准库中的异常：
C++语言（13）——C++异常处理

4.异常处理深度解析

问题1：main函数抛出异常

main函数中跑出异常会发生什么？如果异常不处理会传到哪里？

#include <iostream>

using namespace std;

class Test 
{
public:
    Test() 
    {
        cout << "Test()"; 
        cout << endl;
    }

    ~Test() 
    {
        cout << "~Test()"; 
        cout << endl;
    }
};

int main()
{
    static Test t;

    throw 1;

    return 0;
}

实验结果证明，异常不被处理会导致程序会异常结束，并打印异常语句。
那么异常语句是哪里打印的？
如果异常无法被处理，terminate()函数会被自动调用，该函数用于结束异常，同时在terminate()函数中会调用库函数abort()函数终止程序（abort函数使得程序执行异常并立即退出）。
C++语法支持自定义terminate()函数的实现：
（1）定义一个无返回值无参数的函数（函数类型为void（*）（）类型）
a)不能抛出异常
b)必须以某种方式结束当前程序（abort/exit/…）
（2）调用set_terminate注册自定义的terminate()函数
a)返回值为默认的terminate函数入口地址。

#include <iostream>
#include <cstdlib>
#include <exception>

using namespace std;

void my_terminate()
{
    cout << "void my_terminate()" << endl;
    exit(1);
}

class Test 
{
public:
    Test() 
    {
        cout << "Test()"; 
        cout << endl;
    }

    ~Test() 
    {
        cout << "~Test()"; 
        cout << endl;
    }
};

int main()
{
    set_terminate(my_terminate);

    static Test t;

    throw 1;

    return 0;
}

问题2：析构函抛出异常

析构函数中抛出异常会怎么样？

#include <iostream>
#include <cstdlib>
#include <exception>

using namespace std;

void my_terminate()
{
    cout << "void my_terminate()" << endl;
    // exit(1);
    abort();    // C++ 标准库中terminate()函数调用的为abort直接结束程序，不会再去调用析构函数，防止析构函数中还有异常扔出
}

class Test 
{
public:
    Test() 
    {
        cout << "Test()"; 
        cout << endl;
    }

    ~Test() 
    {
        cout << "~Test()"; 
        cout << endl;

        throw 2;    // terminate函数是整个程序释放资源的最后机会
                    // 析构函数中不能抛出异常，会导致terminate函数被多次调用，造成资源重复释放

    }
};

int main()
{
    set_terminate(my_terminate);

    static Test t;

    throw 1;

    return 0;
}

实验结果证明在Linux这样比较稳定的环境中析构函数中抛出异常会调用terminate()函数。貌似没有什么问题，但对于某些嵌入式系统，可能导致系统的不稳定。
结论：
terminate函数是整个程序释放资源的最后机会。
析构函数中不能抛出异常，会导致terminate函数被多次调用，造成资源重复释放。
C++ 标准库中terminate()函数调用的为abort函数，直接结束程序，不会再去调用析构函数，防止析构函数中还有异常扔出

5.函数异常规格说明

5.1如何判断一个函数是否 会抛出异常，会抛出那些异常？

C++语法提供了用于申明函数所抛出的异常，异常做为函数声明的 修饰符写函数声明的后面。
// 可能抛出任何异常
void fun(void) ;
// 只能抛出int型异常
void fun(void) throw(int);
// 不能抛出异常
void fun(void) throw();

#include <iostream>
using namespace std;

void func() throw(int)
{
    cout << "func()";
    cout << endl;

    throw 'c';
}

int main()
{
    try 
    {
        func();
    } 
    catch(int) 
    {
        cout << "catch(int)";
        cout << endl;
    } 
    catch(char) 
    {
        cout << "catch(char)";
        cout << endl;
    }

    return 0;
}

异常规格说明的意义：
-提示函数调用这必须做好异常处理的准备
-提示函数的维护者不要抛出其他异常
-异常规格 说明是函数接口的一部分。

5.2如果抛出的异常不在申明列表里会发生什么？

函数抛出的异常不在规格说明中，全局函数unexpected()会被调用
默认的unexpected（）函数会调用全局的terminate()函数
可以自定义unexpected()函数
--函数类型void（*）（void）
--能够再次抛出异常
a)在次抛出的异常符合触发函数的异常规格函数时，程序恢复执行
b)否则，调用terminate()函数结束程序
--调用set_unexpected()函数设置自定义的异常函数，返回值为默认的unexpected函数入口地址。
注意不是所有C++编译器都支持这个标准行为，其中vs就不支持（会直接处理抛出的异常，尽管其不在异常规格申明中）。

#include <iostream>
#include <cstdlib>
#include <exception>

/**
函数抛出的异常不在规格说明中，全局函数unexpected()会被调用
    默认的unexpected（）函数会调用全局的terminate()函数
    可以自定义unexpected()函数
        --函数类型void（*）（void）
        --能够再次抛出异常
            a)在次抛出的异常符合触发函数的异常规格函数时，程序恢复执行
            b)否则，调用terminate()函数结束程序
        --调用set_unexpected()函数设置自定义的异常函数，返回值为默认的unexpected函数入口地址。
    注意不是所有C++编译器都支持这个标准行为，其中vs就不支持（会直接处理抛出的异常，尽管其不在异常规格申明中）。
**/

using namespace std;

void my_unexpected()
{
    cout << "void my_unexpected()" << endl;
    // exit(1);
    throw 1;
}

void func() throw(int)
{
    cout << "func()";
    cout << endl;

    throw 'c';
}

int main()
{
    set_unexpected(my_unexpected);

    try 
    {
        func();
    } 
    catch(int) 
    {
        cout << "catch(int)";
        cout << endl;
    } 
    catch(char) 
    {
        cout << "catch(char)";
        cout << endl;
    }

    return 0;
}

6.try ...catch的其他写法

1、try…catch用于分隔正常逻辑的代码和异常处理代码，可以直接将函数实现分隔为两部分。
2、函数声明和定义时可以直接指定抛出的异常类型，异常声明成为函数的一部分可以提高代码的可读性。

#include <iostream>
#include <string>

using namespace std;

int func(int i, int j) throw(int, char)
{
    if( (0 < j) && (j < 10) )
    {
        return (i + j);
    }
    else
    {
        throw '0';
    }
}

void test(int i) try
{
    cout << "func(i, i) = " << func(i, i) << endl;
}
catch(int i)
{
    cout << "Exception: " << i << endl;
}
catch(...)
{
    cout << "Exception..." << endl;
}

int main(int argc, char *argv[])
{
    test(5);

    test(10);

    return 0;
}

显然这种写法可读性降低。
本文参考唐老师课程，特此鸣谢。

推荐阅读：
  1. 13.PL_SQL——异常处理
  2. C++语言学习（十八）——异常处理

免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。

c++ 异常处理 51cto

上一篇：mysql中的死锁是什么？怎么解决

下一篇：SpringMVC源码分析

相关阅读

您好，登录后才能下订单哦！

密码登录
登录注册
获取短信验证码
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》
产品服务
地区划分
帮助支持
关于我们
行业资讯-文章归档 问答-问答归档
广州亿速云计算有限公司

7*24小时在线电话：400-100-2938

7*24小时在线QQ：800811969

Copyright © Yisu Cloud Ltd. All Rights Reserved. 2018 版权所有
粤ICP备17096448号-1 粤公网安备 44010402001142号