C++11中的noexcept说明符和操作符

发表于 | 更新于 | 分类于 |
热度 ℃   |   字数统计: 1,965(字)   |   阅读时长: 8(分) |

前言

noexcept 这个说明符看起来很厉害的样子，给人一种函数加上它就可以不产生异常的感觉，但事实真的如此吗？它真的能消除一切异常吗？答案是不能！它只是函数的一种说明，作为开发者我们需要自己保证标记了 noexcept 的函数不产生异常。啥？这不是没事找事吗？

为什么要用 noexcept

既然给函数添加了 noexcept 说明符并不能杜绝异常的产生，那我们为什么还要用它呢？我个人的理解是为了优化，因为异常存在的意义就是用来干脏活累活的，为了实现异常的处理，我们编写逻辑的每一次函数调用，编译器都会生成一堆外围的处理代码，而当我们把一个函数标记为 noexcept 时，表示开发者向运行时保证调用这个函数不会抛出异常，这意味着这些脏活累活都不用干了，如果声明了 noexcept 的函数还试图抛出异常，C++会调用std::terminate函数终止程序运行。

添加 noexcept 说明符后编译器是否会进行优化，我们可以通过生成的汇编代码来看一下，编译器是 gcc 12.1，先看下面这段代码：

1
2
3
4
5
6
7
8
9
10
11
12
struct Obj
{
    ~Obj();
}

void inner();

void entrance()
{
    Obj instance;
    inner();
}

函数 entrance() 先定义一个Obj类型的对象，然后调用一个 inner() 函数，假如 inner() 在执行过程中抛出了异常，我们需要在保证对象实例 instance 被正确析构后才能退出 entrance() 函数，为了实现了这个保证，编译器真的是操碎了心，可以看一下生成汇编代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
entrance():
        push    rbp
        mov     rbp, rsp
        push    rbx
        sub     rsp, 24
        call    inner()
        lea     rax, [rbp-17]
        mov     rdi, rax
        call    Obj::~Obj() [complete object destructor]
        jmp     .L4
        mov     rbx, rax
        lea     rax, [rbp-17]
        mov     rdi, rax
        call    Obj::~Obj() [complete object destructor]
        mov     rax, rbx
        mov     rdi, rax
        call    _Unwind_Resume
.L4:
        mov     rbx, QWORD PTR [rbp-8]
        leave
        ret

从这段汇编代码中可以发现，有两句是调用了析构函数 Obj::~Obj()，其中第二次就是为了异常发生时准备的，接下来我们加上 noexcept 后代码变成了下面这样：

1
2
3
4
5
6
7
8
9
10
11
12
struct Obj
{
    ~Obj();
};

void inner() noexcept;

void entrance()
{
    Obj o;
    inner();
}

源代码几乎没有变化，而生成的汇编代码清爽了太多：

1
2
3
4
5
6
7
8
9
10
entrance():
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        call    inner()
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    Obj::~Obj() [complete object destructor]
        leave
        ret

对比来看，以下这部分代码一直都是编译器在默默付出，现在你可以通过 noexcept 帮它减负了

1
2
3
4
5
6
7
8
9
10
        jmp     .L4
        mov     rbx, rax
        lea     rax, [rbp-17]
        mov     rdi, rax
        call    Obj::~Obj() [complete object destructor]
        mov     rax, rbx
        mov     rdi, rax
        call    _Unwind_Resume
.L4:
        mov     rbx, QWORD PTR [rbp-8]

实际测试 noexcept

不处理异常

首先实验一下不处理异常时的情景：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>

struct Obj
{
    ~Obj()
    {
        std::cout << "~Obj" << std::endl;
    };
};

void inner()
{
    throw 1;
}

int main()
{
    Obj o;
    inner();

    return 0;
}

编译运行结果如下：

1
2
3
4
albert@home-pc:/mnt/d/data/cpp/testExcept$ g++ testexcept.cpp --std=c++11
albert@home-pc:/mnt/d/data/cpp/testExcept$ ./a.out
terminate called after throwing an instance of 'int'
Aborted (core dumped)

可以看到程序直接崩溃了，在抛出一个异常之后被终止了。

正常捕获异常

再实验一次不加 noexcept 时常规处理异常的方式，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <iostream>

struct Obj
{
    ~Obj()
    {
        std::cout << "~Obj" << std::endl;
    };
};

void inner()
{
    throw 1;
}

int main()
{
    Obj o;

    try
    {
        inner();
    }
    catch(int)
    {
        std::cout << "catch exception." << std::endl;
    }

    return 0;
}

编译运行结果如下：

1
2
3
4
albert@home-pc:/mnt/d/data/cpp/testExcept$ g++ testexcept.cpp --std=c++11
albert@home-pc:/mnt/d/data/cpp/testExcept$ ./a.out
catch exception.
~Obj

异常被捕获，Obj对象被正常析构，程序正常退出了

添加noexcept标记

给函数加上noexcept标记，再测试一次：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <iostream>

struct Obj
{
    ~Obj()
    {
        std::cout << "~Obj" << std::endl;
    };
};

void inner() noexcept
{
    throw 1;
}

int main()
{
    Obj o;

    try
    {
        inner();
    }
    catch(int)
    {
        std::cout << "catch exception." << std::endl;
    }

    return 0;
}

编译运行结果如下：

1
2
3
4
albert@home-pc:/mnt/d/data/cpp/testExcept$ g++ testexcept.cpp --std=c++11
albert@home-pc:/mnt/d/data/cpp/testExcept$ ./a.out
terminate called after throwing an instance of 'int'
Aborted (core dumped)

我们看到加了noexcept如果抛出异常，程序会被直接终止，try...catch 语句就不起作用了，所以 noexcept 不能随便加，一定得保证确实没有异常才可以应用此优化。

noexcept操作符

noexcept本身后面可以加一个表达式，返回一个bool值，用来判定一个函数是否会抛出异常，可以看一下这个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>

void inner() noexcept
{
    throw 1;
}

void test();

void test2() noexcept;

int main()
{
    std::cout << std::boolalpha
        << "Is inner() noexcept? " << noexcept(inner()) << std::endl
        << "Is test() noexcept? " << noexcept(test()) << std::endl
        << "Is tes2() noexcept? " << noexcept(test2()) << std::endl;
}

编译运行后的结果如下：

1
2
3
4
5
albert@home-pc:/mnt/d/data/cpp/testExcept$ g++ testexcept.cpp --std=c++11
albert@home-pc:/mnt/d/data/cpp/testExcept$ ./a.out
Is inner() noexcept? true
Is test() noexcept? false
Is tes2() noexcept? true

test() 和 test2() 函数的判断应该没有什么疑问，而 inner()明明会抛出异常，而 noexcept操作符却返回了false，这是因为我们在函数后面加上了 noexcept 说明符，这时就需要我们自己保证函数不会抛出异常了，如果你硬要抛出异常那编译器也没有办法了。

noexcept的优缺点

优点

调用标记为 noexcept 的函数时不需要额外记录exception handler，所以编译器拥有更高的自由度，便于生成更加高效的执行代码。

缺点

noexcept关键字啊会影响接口的灵活性，如果基类某个虚函数设置为noexcept，派生类重写虚函数时也必须遵守，派生类中只要有一个函数遗漏了noexcept约定，就可能会导致整个程序在发生异常时被终止。

如果标记为noexcept的函数调用了第三方库的函数，就需要对这些第三方库都做一层封装，保证处理了第三方库所有可能抛出的异常，增大了工作量。

总结

  • noexcept 是一个说明符同时也是一个操作符
  • noexcept 作为说明符放在函数名后面，表明次函数不会抛出异常，等同于 noexcept(true)
  • noexcept 作为操作符时，可以用来判断一个函数是否会抛出异常，用法为 noexcept(funcName)
  • 当使用 noexcept 标记函数时，我们需要自己保证函数不会抛出异常，这样可以生成更高效的代码
  • 如果标记了 noexcept函数还是抛出了异常，那么程序会直接调用 std::abort() 终止程序，try...catch都没用
==>> 反爬链接，请勿点击，原地爆炸，概不负责！<<==

曾经接受教育努力学习是打破阶级固化的长矛，如今教育更多表现为阻碍阶级跨越的护盾，不能否认好好学习可以让我们的生活变得更好，但寒门再难出贵子确实是摆在我们面前的现实，马太效应，强者愈强、弱者愈弱。条条大路通罗马，而有些人就生在罗马，我们只能靠自己微弱的锋利，去尝试突破那一层层禁锢。

2022-6-26 17:23:42

Albert Shi wechat
欢迎您扫一扫上面的微信公众号，订阅我的博客