std::experimental::scope_fail

 

C++

编译器支持

自由（freestanding）与宿主（hosted）

语言

标准库

标准库头文件

具名要求

特性测试宏 (C++20)

语言支持库

概念库 (C++20)

诊断库

内存管理库

元编程库 (C++11)

通用工具库

容器库

迭代器库

范围库 (C++20)

算法库

字符串库

文本处理库

数值库

日期和时间库

输入/输出库

文件系统库 (C++17)

并发支持库 (C++11)

执行控制库 (C++26)

技术规范

符号索引

外部库

 

实验性

技术规范

文件系统库 (文件系统 TS)

库基础 (库基础 TS)

库基础 2 (库基础 TS v2)

库基础 3 (库基础 TS v3)

并行性扩展 (并行性 TS)

并行性扩展 2 (并行性 TS v2)

并发性扩展 (并发性 TS)

并发扩展2 (concurrency TS v2)

概念 (概念 TS)

范围 (范围 TS)

反射 (反射 TS)

数学特殊函数 (特殊函数 TR)

实验性非 TS

模式匹配

线性代数

std::execution

契约

2D 图形

 

库基础 v3

experimental::scope_exit

experimental::scope_fail

experimental::scope_success

experimental::unique_resource

 

std::experimental::scope_fail

成员函数

scope_fail::scope_fail

scope_fail::~scope_fail

修改器

scope_fail::release

推导指引

 

定义于头文件 <experimental/scope>
template< class EF > class scope_fail;		(库基础 TS v3)

类模板 scope_fail 是一个通用的作用域守卫，旨在当作用域因异常而退出时调用其退出函数。

scope_fail 不可 CopyConstructible、不可 CopyAssignable 且不可 MoveAssignable，但是，如果 EF 满足某些要求，它可能是 MoveConstructible 的，这允许将 scope_fail 包装到另一个对象中。

scope_fail 可以是活动的（即在析构时调用其退出函数），也可以是非活动的（即在析构时不做任何事情）。从退出函数构造后，scope_fail 是活动的。

scope_fail 可以通过手动或自动（通过移动构造函数）调用其 release() 变为非活动状态。通过用另一个非活动的 scope_fail 初始化也可以获得非活动的 scope_fail。一旦 scope_fail 变为非活动状态，它就不能再次变为活动状态。

scope_fail 实际上持有一个 EF 和一个 bool 标志，指示它是否处于活动状态，以及一个未捕获异常的计数器，用于检测析构函数是否在栈展开期间被调用。

模板参数

EF	-	存储的退出函数的类型
类型要求
- EF 应为以下之一： 一个 可析构的 函数对象 类型， 一个对 FunctionObject 的左值引用， 一个对函数的左值引用。
- 调用 std::remove_reference_t<EF> 的左值且无参数应是良构的。

成员函数

(构造函数)	构造一个新的 scope_fail (public member function)
(析构函数)	如果 scope_fail 是活动的，则当作用域因异常而退出时调用退出函数，然后销毁 scope_fail (public member function)
operator= [已删除]	scope_fail 不可赋值 (公开成员函数)
修改器
release	使 scope_fail 变为非活动状态 (public member function)

注意

构造动态存储期的 scope_fail 可能会导致意外行为。

从在不同线程中创建的另一个 scope_fail 构造 scope_fail 也可能导致意外行为，因为在销毁期间可能会比较在不同线程中获得的未捕获异常的计数。

示例

运行此代码

#include <iostream>
#include <cstdlib>
#include <string_view>
#include <experimental/scope>
 
void print_exit_status(std::string_view name, bool exit_status, bool did_throw) {
  std::cout << name << ":\n";
  std::cout << "  Throwed exception  " << (did_throw ? "yes" : "no") << "\n";
  std::cout << "  Exit status        " << (exit_status ? "finished" : "pending") << "\n\n";
}
 
// Randomly throw an exception (50% chance)
void maybe_throw() {
    if (std::rand() >= RAND_MAX / 2)
        throw std::exception{};
}
 
int main() {
  bool exit_status{false}, did_throw{false};
 
  // Manual handling at "end of scope"
  try {
    maybe_throw();
    exit_status = true; 
  } catch (...) { did_throw = true; }
  print_exit_status("Manual handling", exit_status, did_throw);
 
  // Using scope_exit: runs on scope exit (success or exception)
  exit_status = did_throw = false;
  try {
    auto guard = std::experimental::scope_exit{[&]{ exit_status = true; } };
    maybe_throw();
  } catch (...) { did_throw = true; }
  print_exit_status("scope_exit", exit_status, did_throw);
 
  // Using scope_fail: runs only if an exception occurs
  exit_status = did_throw = false;
  try {
    auto guard = std::experimental::scope_fail{[&]{ exit_status = true; } };
    maybe_throw();
  } catch (...) { did_throw = true; }
  print_exit_status("scope_fail", exit_status, did_throw);
 
  // Using scope_success: runs only if no exception occurs
  exit_status = did_throw = false;
  try {
    auto guard = std::experimental::scope_success{[&]{ exit_status = true; } };
    maybe_throw();
  } catch (...) { did_throw = true; }
  print_exit_status("scope_success", exit_status, did_throw);
}

输出

Manual handling:
  Throwed exception  yes
  Exit status        pending
 
scope_exit:
  Throwed exception  no
  Exit status        finished
 
scope_fail:
  Throwed exception  yes
  Exit status        finished
 
scope_success:
  Throwed exception  yes
  Exit status        pending

另见

scope_exit	封装一个函数对象并在退出作用域时调用它 (class template)
scope_success	封装一个函数对象并在正常退出作用域时调用它 (class template)
default_delete (C++11)	unique_ptr 的默认删除器 (class template)