std::experimental::scope_exit(3)

NAME
std::experimental::scope_exit - std::experimental::scope_exit

Synopsis
   Defined in header <experimental/scope>
   template<class EF> (library fundamentals TS v3)
   class scope_exit;
   The class template scope_exit is a general-purpose scope guard intended to call its
   exit function when a scope is exited.
   scope_exit is not CopyConstructible, CopyAssignable or MoveAssignable, however, it
   may be MoveConstructible if EF meets some requirements, which permits wrapping a
   scope_exit into another object.
   A scope_exit may be either active, i.e. calls its exit function on destruction, or
   inactive, i.e. does nothing on destruction. A scope_exit is active after constructed
   from an exit function.
   A scope_exit can become inactive by calling release() on it either manually or
   automatically (by the move constructor). An inactive scope_exit may also be obtained
   by initializing with another inactive scope_exit. Once a scope_exit is inactive, it
   cannot become active again.
   A scope_exit effectively holds an EF and a bool flag indicating if it is active.

Template parameters
   EF - type of stored exit function

Type requirements
   -
   EF shall be either:
     * a Destructible FunctionObject type
     * an lvalue reference to FunctionObject
     * an lvalue reference to function
   -
   Calling an lvalue of std::remove_reference_t<EF> with no argument shall be
   well-formed.

Member functions
   constructor constructs a new scope_exit
                 (public member function)
                 calls the exit function when the scope is exited if the scope_exit is
   destructor active, then destroys the scope_exit
                 (public member function)
   operator= scope_exit is not assignable
   [deleted] (public member function)

Modifiers
   release makes the scope_exit inactive
                 (public member function)
  Deduction guides

Notes
   Constructing a scope_exit of dynamic storage duration might lead to unexpected
   behavior.
   If the EF stored in a scope_exit object refers to a local variable of the function
   where it is defined, e.g., as a lambda capturing the variable by reference, and that
   variable is used as a return operand in that function, that variable might have
   already been returned when the scope_exit's destructor executes, calling the exit
   function. This can lead to surprising behavior.

Example
    This section is incomplete
    Reason: no example

See also
                  wraps a function object and invokes it on exiting the scope through
   scope_fail an exception
                  (class template)
   scope_success wraps a function object and invokes it on exiting the scope normally
                  (class template)
   default_delete default deleter for unique_ptr
   (C++11) (class template)