C++异常之四 异常类型的生命周期

异常类型的生命周期

 

1. throw 基本类型：

int、float、char

这三种类型的抛出和函数的返回传值类似，为参数拷贝的值传递。

int test_1(int num) throw (int, double, char)
{
    if (num == 0)
    {
        throw -1;
    }else if (num == 1){
        throw 0.01;
    }else{
        throw 'A';
    }

    return 0;
}

int main()
{
    int ret = 0;
    try
    {
        ret = test_1(2);
    }
    catch (int error) {
        printf("捕捉到 int 类型异常：%d", error);
    }catch (double error) {
        printf("捕捉到 double 类型异常：%f", error);
    }catch (char error) {
        printf("捕捉到 char 类型异常：%c", error);
    }

    return 0;
}

 

 

2　throw 字符串类型：

string、char[num]

与普通变量区别不大，字符串抛出的是字符串的地址，如下边的代码：

test() 传1 过去运行结果：

抛出 char * 字符串异常地址为：0097CDB8
char* error = (char*)被捕获异常地址为：0097CDB8

test() 传2 过去运行结果：

抛出 string 字符串异常地址为：00CE5F18
string *error = new string被捕获异常地址为：00CE5F18

抛出字符串与普通变量也没有多大区别，也是值传递，但传的是指针，而且修饰指针的 const 也要严格进行类型匹配。

int test(int num) throw (char *, string)
{
    if(num == 1)
    {
        const char* error = "char* error = (char*)";            //修饰指针的 const 也要严格进行类型匹配。
        printf("抛出 char * 字符串异常地址为：%p\n", error);
        throw error;
    }
    else if (num == 2) 
    {
        string *error = new string("string *error = new string");
        printf("抛出 string 字符串异常地址为：%p\n", error);
        throw error;
    }

    return 0;
}

int main()
{
    int ret = 0;
    try
    {
        ret = test(1);
    }
    catch (const char *error)
    {
        printf("%s被捕获", error);        
        printf("异常地址为：%p\n", error);
    }
    catch (string *error)
    {
        printf("%s被捕获", error->c_str());
        printf("异常地址为：%p\n", error);
        //别忘记释放内存
        delete error;
    }

    return 0;
}

 

 

3　throw 类类型异常：

　　首先要说明，throw 类类型的最佳方式是：抛出类的匿名对象，使用引用类型捕捉对象，这种方法效率最高，下边将会具体说明。

 　　throw 类类型的生存周期分几种情况，生存周期的不同与编译器对于类的处理有关，用下方的代码举例：

#include <iostream>
#include <string>

class ErrorException
{
public:
    ErrorException();
    ~ErrorException();
    ErrorException(const ErrorException& error);

private:
    int ID = -1;
};

ErrorException::ErrorException()
{
    ID = 0;
    printf("ErrorException 构造\n");
}

ErrorException ::~ErrorException()
{
    printf("ErrorException ~析构 (ID：%d)\n", ID);
}

ErrorException::ErrorException(const ErrorException& error)
{
    ID = 1;
    printf("ErrorException 拷贝构造函数\n");
}

int test(int num) throw (ErrorException)
{
    if (num == 1)
    {
        throw ErrorException();　　　　　　//这里抛出的是匿名对象
    }

    return 0;
}

int main()
{
    int ret = 0;
    try
    {
        ret = test(1);
    }
    catch (ErrorException &error)
    {
        printf("捕捉到异常！ErrorException 类型\n");
    }
    catch (...)
    {
        printf("没有捕捉到异常类型\n");
    }

    return 0;
}

===================================================================================
第49行如果 error 没有引用，运行结果：

ErrorException 构造
ErrorException 拷贝构造函数
捕捉到异常！ErrorException 类型
ErrorException ~析构 (ID：1)
ErrorException ~析构 (ID：0)

说明：调用了两次析构函数，一次是在 36行创建了匿名对象抛出，一次是在49行，因为使用了形参值传递，会进行两个对象的创建。

从ID 的变化可以看出，先析构拷贝构造函数，后析构构造函数。

===================================================================================
第49行如果 error 使用了引用，运行结果：

ErrorException 构造
捕捉到异常！ErrorException 类型
ErrorException ~析构 (ID：0)

说明：使用引用的话，将会少创建一个对象，是36行的“临时匿名对象”的地址进行抛出，捕捉时直接捕捉引用，不用再次创建，这种效率最高。

===================================================================================
第36行，如果先创建对象，然后37行 throw 对象，50行用形参接收，则会变得更加低效，这一切要说下编译器在背地里做的很多事情，如下代码：

/* . . . 省略 . . . */
int test(int num) throw (ErrorException)
{
    if (num == 1)
    {
        ErrorException error;　　　　　　　　　　//进行对象创建
        throw error;　　　　　　　　　　　　　　　//进行对象抛出
    }

/* . . . 省略 . . . */
    try
    {
        ret = test(1);
    }
    catch (ErrorException error)　　　　　　　　//使用形参接收
    {
        printf("捕捉到异常！ErrorException 类型\n");
    }

运行结果：

ErrorException 构造
ErrorException 拷贝构造函数 
ErrorException 拷贝构造函数
ErrorException ~析构 (ID：0)
捕捉到异常！ErrorException 类型
ErrorException ~析构 (ID：1)
ErrorException ~析构 (ID：1)

说明：

ErrorException 构造　　　　　　　　　------------> 36 行创建对象
ErrorException 拷贝构造函数 　　　　　-----------> 由于 36 行创建的对象作用域在函数内部，但异常要继续往外抛，编译器会创建一个“临时的匿名对象”。
ErrorException 拷贝构造函数　　　　　------------> 第50行创建的error，用上边生成的“临时的匿名对象”进行拷贝。
ErrorException ~析构 (ID：0)　　　　　------------> 由于 test 函数结束，36行创建的对象被析构。
捕捉到异常！ErrorException 类型　　　 -----------> 进入到 52 行打印。
ErrorException ~析构 (ID：1)　　　　　------------> 第50行创建的error对象，走出作用域销毁。
ErrorException ~析构 (ID：1)　　　　　------------> 离开第50行的 catch 的作用域时 “临时的匿名对象”被销毁。

 

===================================================================================

 　　如果使用指针进行异常抛出，大同小异，用上边的代码举例，要注意的就是内存的释放，如下代码：

/* . . . 省略 . . . */
int test(int num) throw (ErrorException)
{
    if (num == 1)
    {
        throw new ErrorException();　　　　　　　　　　　　　　　　　　　　//动态内存分配
    }

/* . . . 省略 . . . */
    catch (ErrorException *error)
    {
        printf("捕捉到异常！ErrorException 类型\n");
        delete error;　　　　　　　　　　　　　　　　　　　　　　　　　　　　//注意释放内存
    }

　　运行结果：

ErrorException 构造
捕捉到异常！ErrorException 类型
ErrorException ~析构 (ID：0)

　　 ===================================================================================

 

 

1. 异常处理的三个关键字

点击查看

2. 异常处理的基本语法

点击查看

3.异常处理接口声明

点击查看

4.异常类型的生命周期

4.1　throw 基本类型：

点击查看

4.2　throw 字符串类型：

点击查看

4.3　throw 类类型异常：

点击查看

5.异常和继承

点击查看

6.异常处理的基本思想

点击查看 

7.标准库里的异常类

点击查看