std::experimental::scope_exit<EF>::scope_exit

From cppreference.com

 
C++
 
Technical specifications
Filesystem library (filesystem TS)
Library fundamentals (library fundamentals TS)
Library fundamentals 2 (library fundamentals TS v2)
Library fundamentals 3 (library fundamentals TS v3)
Extensions for parallelism (parallelism TS)
Extensions for parallelism 2 (parallelism TS v2)
Extensions for concurrency (concurrency TS)
Concepts (concepts TS)
Ranges (ranges TS)
Mathematical special functions (special functions TR)
 
Library fundamentals v3
 
std::experimental::scope_exit
Member functions
scope_exit::scope_exit
Modifiers
Deduction guides
 
template <class Fn>
explicit scope_exit( Fn&& fn ) noexcept(/*see below*/);
 (1) (library fundamentals TS v3)
scope_exit( scope_exit&& other ) noexcept(/*see below*/);
 (2) (library fundamentals TS v3)
scope_exit( const scope_exit& ) = delete;
 (3) (library fundamentals TS v3)

Creates a scope_exit from a function, a function object or another scope_exit.

1) Initializes the exit function with a function or function object. The constructed scope_exit is active.
If Fn is not an lvalue reference type and std::is_nothrow_constructible_v<EF, Fn> is true, the stored EF is initialized with std::forward<Fn>(fn); otherwise it is initialized with fn.
If initialization of the stored EF throws an exception, calls fn().
This overload only participates in overload resolution if std::is_same_v<std::remove_cvref_t<Fn>, scope_exit> is false and std::is_constructible_v<EF, Fn> is true.
The behavior is undefined if
  • Fn&& is neither a reference to function nor a reference to function object, or
  • the function call expression fn() is ill-formed, or
  • fn() throws an exception or results in undefined behavior, even if fn has not been called.
2) Move constructor. Initializes the stored EF with the one in other. The constructed scope_exit is active if and only if other is active before the construction.
If std::is_nothrow_move_constructible_v<EF> is true, initializes stored EF (denoted by exitfun) with std::forward<EF>(other.exitfun), otherwise initializes it with other.exitfun.
After successful move construction, other.release() is called and other becomes inactive.
This overload only participates in overload resolution if std::is_nothrow_move_constructible_v<EF> is true or std::is_copy_constructible_v<EF> is true.
The behavior is undefined if
3) scope_exit is not CopyConstructible.

Parameters

fn - function or function object used for initializing the stored EF
other - scope_exit to move from

Exceptions

Any exception thrown during the initialization of the stored EF.

1)
noexcept specification:  
noexcept(std::is_nothrow_constructible_v<EF, Fn> ||
std::is_nothrow_constructible_v<EF, Fn&>)
2)
noexcept specification:  
noexcept(std::is_nothrow_move_constructible_v<EF> ||
std::is_nothrow_copy_constructible_v<EF>)

Example

This section is incomplete
Reason: no example

See also

 makes the scope_exit inactive
(public member function)
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/experimental/scope_exit/scope_exit&oldid=115129"