C++11 鼓励对肯定不抛出异常的函数添加 noexcept 修饰

最新推荐文章于 2023-01-16 20:00:26 发布

「已注销」

最新推荐文章于 2023-01-16 20:00:26 发布

阅读量689

点赞数

分类专栏： Effectivve Modern Cpp 文章标签： c++ 开发语言后端

本文链接：https://blog.csdn.net/rubikchen/article/details/122117348

版权

Effectivve Modern Cpp 专栏收录该内容

25 篇文章 1 订阅

订阅专栏

                    
                        
                    
                     总览 
   
    新机制 
      
       对noexcept修饰的函数进行优化. 
 noexcept可以传导和查询. 
 
      
 异常 
      
       用异常代替if else. 
 将if else统一到一个地方处理. 
 
      
 异常 
      
       必须处理的错误,直接抛出异常. 
 不需要处理的错误. 
 
      
 noexcept函数 
      
       任意时刻调用都不会出错. 
 noexcept可以是非noexcept组成. 
 
      
 主流函数 
      
       大部分都是可能抛出异常的. 
 不一定非要追求noexcept,不要用return code代替异常. 
 
      
 错误检测 
      
       调用者保障. 
 直接抛出异常. 
 
      
 
   
 C++的异常 
   
    C++98异常 
      
       可以通过throw(...)枚举可能抛出的异常. 如果抛出了预期外的则终止程序. 
 但是统一性的问题. 使用者很可能会对使用的函数将要throw的异常比较关注. 
 
      
 C++98一致性 
      
       使用程序的开发者对函数进行了修改,抛出的异常变化了. 
 那么就需要改动throw(...)里面的枚举,那么就会导致一些列相关的代码也需要修改. 
 带来的问题,编译器也不会提醒,就会带来一系列的问题. 
 这种设计是不好的,但是有些场景又是必须的. 
 
      
 C++11 
      
       只有两种状态: 肯定不会 和 可能会 . 
 noexcept或noexcept(true) 修饰的肯定不会. 其他则可能会. 
 
      
 C++11和C++98的差异 
      
       C++11的noexcept修饰,即肯定不会抛异常的函数会进行优化. 
 C++98则会尝试优化,但是还是会保留一些额外的信息. 
 C++98不抛出异常:throw(),C++11则是noexcept,noexcept(true). 
 C++98出现期望之外的异常执行析构. C++11 遇到期望之外的会立即崩溃,不会清理资源.被优化掉了. 
 
      
 接口设计 
      
       在设计接口的时候就应该明确,是否可能会抛出异常. 
 而且接口需要稳定,遵循开闭原则. 
 
      
 函数是否异常的影响 
      
       影响编译. 
 影响使用者的代码实现和架构设计。 
 
      
 重要性 
      
       和函数的const修饰一样. 
 但是noexcept不参与重载修饰. 
 
      
 C++98和C++11差异案例 
      
       C++98会清理资源,返回到调用者,再崩溃. 
 
      [root@localhost test]# g++ test.cpp -std=c++98
[root@localhost test]# cat test.cpp
#include <iostream>

class T {
public:
   T() {std::cout << __FUNCTION__ << std::endl;}
   ~T() {std::cout << __FUNCTION__ << std::endl;}
};

void show() throw()
{
   T t;
   throw 1;
}

int main() {
   show();
}
[root@localhost test]# ./a.out
T
~T
terminate called after throwing an instance of 'int'
Aborted

 
       C++11不会,直接崩溃.栈回指只会发生在程序结束.编译器直接把释放的代码给优化掉了.不需要.因为已经保证肯定不会抛出异常. 
 
      [root@localhost test]# g++ test.cpp -std=c++11
[root@localhost test]# cat test.cpp
#include <iostream>

class T {
public:
   T() {std::cout << __FUNCTION__ << std::endl;}
   ~T() {std::cout << __FUNCTION__ << std::endl;}
};

void show() noexcept
{
   T t;
   throw 1;
}

int main() {
   show();
}
[root@localhost test]# ./a.out
T
terminate called after throwing an instance of 'int'
Aborted

 
      
 编译器优化 
      
       void func() noexcept:全力优化; void func() throw():简单优化; void func():简单优化; 
 
      
 小结 
      
       就noexcept函数会被编译器优化这一点,开发者就应该对肯定不会抛出异常的函数加上这个修饰. 
 
      
 
   
 noexcept场景分析 
   
    std::vector添加元素. 
      
       添加导致,但是内存不足需要扩容. 
 
      
 正确性问题 
      
       如果拷贝的时候出现异常.数据如何处理.copy中发生异常,原来的数据还是完整的. 
 拷贝失败,捕获还是什么? 
 C++11采用move的方式优化,但是问题是,move到一半,发生异常,原来的数据被修改,也无法回滚. 
 
      
 C++11做法 
      
       拷贝根据类型的拷贝构造是否会抛出异常,选择使用元素的拷贝构造还是移动构造. 
 
      
 案例 
      
      #include <iostream>

class T {
public:
   T() {std::cout << this << std::endl;}
   T(const T& t) noexcept {std::cout << "copy"  << this << std::endl;}
   T(T&& t) noexcept {std::cout << "move"  << this << std::endl;}
   ~T() {std::cout << this << std::endl;}
};

void show(T t) noexcept(noexcept(T(std::move(t)))){
   if(noexcept(T(std::move(t)))) {
       std::cout << "noexcept t " << &t << std::endl;
       T d(std::move(t));
       std::cout << "noexcept d " << &d << std::endl;
   } else {
       std::cout << "except t " << &t << std::endl;
       T d(t);
       std::cout << "except d " << &d << std::endl;
   }
}

int main() {
   T t;
   show(t);
}
 
       noexcept版本的move. 
 
      0x61fe1e
copy 0x61fe1f
noexcept t 0x61fe1f
move 0x61fddf
noexcept d 0x61fddf
0x61fddf
0x61fe1f
0x61fe1e
[Finished in 485ms]
 
       except版本 
 
      #include <iostream>

class T {
public:
   T() {std::cout << this << std::endl;}
   T(const T& t) noexcept {std::cout << "copy" << this << std::endl;}
   T(T&& t)  {std::cout << this << "move" << std::endl;}
   ~T() {std::cout << this << std::endl;}
};

void show(T t) noexcept(noexcept(T(std::move(t)))){
   if(noexcept(T(std::move(t)))) {
       std::cout << "noexcept t " << &t << std::endl;
       T d(std::move(t));
       std::cout << "noexcept d " << &d << std::endl;
   } else {
       std::cout << "except t " << &t << std::endl;
       T d(t);
       std::cout << "except d " << &d << std::endl;
   }
}

int main() {
   T t;
   show(t);
}
 
       输出 
 
      0x61fd3e
copy 0x61fd3f
except t 0x61fd3f
copy 0x61fbae
except d 0x61fbae
0x61fbae
0x61fd3f
0x61fd3e
[Finished in 472ms]
 
      
 建议 
      
       拷贝,移动,swap这些函数实现成noexcept. 
 拷贝和移动,析构默认是noexcept,但是默认生成的行为不符合预期. 
 
      
 扩展 
      
      #include <iostream>
void show(int a) noexcept(noexcept(a) && noexcept(a)){
}

int main() {
   int a;
   show(a);
}
 
       可以多个表达式,与或非. 
 
      
 
   
 优化和noexcept 
   
    回顾 
      
       前面的优化方案令人心动.是不是声明了程序就可以跑得更快了。 
 但是正确性和开发效率，代码整洁等等都是需要考量的。 
 
      
 设计 
      
       先声明为noexcept,后期再改回来? 
 随意改动会影响到其他使用到这个函数的人,不建议随意修改,自己使用另说. 
 
      
 改成noexcept 
      
       修改成noexcept,但是使用了可能抛异常的,就会导致异常无法传递,然后崩溃. 
 
      
 主流 
      
       都是 异常中立函数. 异常中立函数就是没有声明任何异常,也不是noexcept. 
 这类可以传递使用的代码抛出的异常. 然后不做处理就直接放行. 
 
      
 默认noexcept 
      
       编译器提供的拷贝和移动. 
 
      
 肯定不会抛异常的函数 
      
       建议使用noexcept修饰. 
 
      
 异常和返回值 
      
       将异常捕获改成返回值的方式,然后把函数改成noexcept,这种就有点本末倒置了. 
 
      
 
   
 noexcept和开发 
   
    noexcept 
      
       虽然执行效率高,但是适用性不是特别广. 
 
      
 异常的好处 
      
       使用exception替代返回值的方式可以提高开发效率. 
 可以减少因为返回值带来的if else判断分支. 
 可以避免if else带来的函数膨胀. 
 可以简化代码结构.将if else放到另外的地方处理. 
 
      
 返回值的弊端 
      
       虽然noexcept可能会很快,但是代价就是导致代码复杂. 
 代码结构混乱,分支变多,维护麻烦. 
 带来的一系列问题和开销可能还不如用异常来处理. 
 
      
 提供功能 
      
       功能提供者不应该检测数据的有效性. 
 应该由调用者确保数据的合法性. 
 外观模式的主要核心就是保障合法. 
 出现问题则就应该直接抛出异常,让调用者自行处理. 
 
      
 
   
 函数设计 
   
    wide contracts | narrow contracts 
      
       wide就是不检测入参无限制,程序任意时刻可运行. 
 narrow就是入参有限制,错误参数程序会出错. 
 
      
 wide常见就是 
      
      #include <iostream>
void show(int a){
}

int main() {
   int a;
   show(a);
}
 
       无任何要求,什么值都可以. 
 
      
 narrow 
      
      #include <iostream>
void show(int a){
   int c = 10 / a;
}

int main() {
   int a;
   show(a);
}
 
       a明显不能等于0. 但是不会检查,由调用者保证有效. 
 
      
 noexcept 
      
       这类最可能将函数声明为noexcept. 
 
      
 narrow 
      
       没有责任检测合法性, 会带来很多分支和性能的开销. 
 应该由调用者检查合法性,有的时候甚至不需要检测. 
 检查不强制,函数实现者也可以在函数内检测,不反对但是不推荐. 
 
      
 
   
 noexcept不一定非要noexcept实现 
   
    wide 
      
       什么场景都不会出现问题,直接noexcept. 
 
      
 wide和narrow区分 
      
       wide一般用noexcept,narrow则没有. 
 
      
 noexcept调用非noexcept 
      
      #include<iostream>
void setup(); // functions defined elsewhere
void cleanup();
void doWork() noexcept
{
setup(); // set up work to be done
// … // do the actual work
cleanup(); // perform cleanup actions
}

int main() {
   doWork();
}

void setup() {
   printf("%s\n",__FUNCTION__);
}

void cleanup() {
   printf("%s\n",__FUNCTION__);
}

 
       调用非noexcept,可能是C函数,没有noexcept. 
 或者就是C++98的,没有noexcept. 
 
      
 
   
 总结 
   
    noexcept对使用者很重要. 
 noexcept的效率高,但是不要可以强求. 
 noexcept在move,swap析构这些场景非常适合. 
 主流的是抛异常函数而非noexcept. 
 
   

                