std::experimental::scope_exit

 

C++

编译器支持

独立和宿主式

语言

标准库

标准库头文件

具名要求

特性测试宏 (C++20)

语言支持库

概念库 (C++20)

诊断库

内存管理库

元编程库 (C++11)

通用工具库

容器库

迭代器库

范围库 (C++20)

算法库

字符串库

文本处理库

数值库

日期和时间库

输入/输出库

文件系统库 (C++17)

并发支持库 (C++11)

执行控制库 (C++26)

技术规范

符号索引

外部库

 

实验性

技术规范

文件系统库 (filesystem TS)

库基础 (library fundamentals TS)

库基础 2 (library fundamentals TS v2)

库基础 3 (library fundamentals TS v3)

并行性扩展 (parallelism TS)

并行性扩展 2 (parallelism TS v2)

并发性扩展 (concurrency TS)

并发性扩展 2 (concurrency TS v2)

概念 (concepts TS)

范围 (ranges TS)

反射 (reflection TS)

数学特殊函数 (special functions TR)

实验性非TS

模式匹配

线性代数

std::execution

契约

2D 图形

 

库基础 v3

experimental::scope_exit

experimental::scope_fail

experimental::scope_success

experimental::unique_resource

 

std::experimental::scope_exit

成员函数

scope_exit::scope_exit

scope_exit::~scope_exit

修饰符

scope_exit::release

推导指引

 

定义于头文件 <experimental/scope>
template< class EF > class scope_exit;		(library fundamentals TS v3)

类模板 scope_exit 是一个通用的作用域守卫，旨在作用域退出时调用其退出函数。

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

scope_exit 可以是活动的，即在销毁时调用其退出函数；也可以是不活动的，即在销毁时什么也不做。scope_exit 在从退出函数构造后是活动的。

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

scope_exit 有效地保存一个 EF 和一个指示其是否活动的 bool 标志。

模板参数

EF	-	存储的退出函数的类型
类型要求
- EF 应当是以下之一 一个 Destructible FunctionObject 类型， 一个到 FunctionObject 的左值引用， 一个到函数的左值引用。
- 调用不带参数的 std::remove_reference_t<EF> 的左值应当是良构的。

成员函数

(构造函数)	构造一个新的 scope_exit (公共成员函数)
(析构函数)	如果 scope_exit 是活动的，则在作用域退出时调用退出函数，然后销毁 scope_exit (公共成员函数)
operator= [已删除]	scope_exit 不可赋值 (公共成员函数)
修饰符
release	使 scope_exit 变为不活动 (公共成员函数)

备注

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

如果存储在 scope_exit 对象中的 EF 引用了定义它的函数的局部变量，例如，作为按引用捕获变量的 lambda，并且该变量在该函数中用作返回操作数，则当 scope_exit 的析构函数执行（调用退出函数）时，该变量可能已经被返回。这可能会导致令人惊讶的行为。

示例

运行此代码

#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_fail	封装一个函数对象，并在通过异常退出作用域时调用它 (类模板)
scope_success	封装一个函数对象，并在正常退出作用域时调用它 (类模板)
default_delete (C++11)	unique_ptr 的默认删除器 (类模板)