std::experimental::scope_success
|
Defined in header
<experimental/scope>
|
||
|
template< class EF >
class scope_success; |
(library fundamentals TS v3) | |
The class template scope_success is a general-purpose scope guard intended to call its exit function when a scope is normally exited.
scope_success is not CopyConstructible, CopyAssignable or MoveAssignable, however, it may be MoveConstructible if EF meets some requirements, which permits wrapping a scope_success
A scope_success may be either active, i.e. calls its exit function on destruction, or inactive, i.e. does nothing on destruction. A scope_success is active after constructed from an exit function.
A scope_success can become inactive by calling release() on it either manually or automatically (by the move constructor). An inactive scope_success may also be obtained by initializing with another inactive scope_success. Once a scope_success
A scope_success effectively holds an EF and a
bool
Template parameters
| EF | - | type of stored exit function |
| Type requirements | ||
-
EF shall be either:
|
||
| -Calling an lvalue of std::remove_reference_t<EF> | ||
Member functions
constructs a new scope_success (public member function) |
|
calls the exit function when the scope is exited normally if the scope_success is active, then destroys the scope_success (public member function) |
|
operator= [deleted] |
scope_success is not assignable (public member function) |
Modifiers | |
makes the scope_success inactive (public member function) |
|
Deduction guides
Notes
Constructing a scope_success of dynamic storage duration might lead to unexpected behavior.
Constructing a scope_success is constructed from another scope_success
If the EF stored in a scope_success
scope_success
Example
#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); }
Output:
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
See also
| wraps a function object and invokes it on exiting the scope (class template) |
|
| wraps a function object and invokes it on exiting the scope through an exception (class template) |
|
|
(C++11)
|
default deleter for unique_ptr (class template) |