home | help 
std::experi...::scope_exit(3)  C++ Standard Libary std::experi...::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  de-
     struction, 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 manu-
     ally 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  un-
     expected
	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  refer-
     ence, 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)

Category:
	  * Todo no example

http://cppreference.com 	   2024.06.10	   std::experi...::scope_exit(3)
home | help