home | help 
std::experi...ue_resource(3)   C++ Standard Libary  std::experi...ue_resource(3)

NAME
     std::experimental::unique_resource - std::experimental::unique_resource

Synopsis
	Defined in header <experimental/scope>
	template< class R, class D >		(library fundamentals TS v3)
	class unique_resource;

	unique_resource is universal RAII wrapper for resource handles that owns
     and manages
	a  resource  through  a  handle  and  disposes of that resource when the
     unique_resource
	is destroyed.

	The resource is disposed of using the deleter of type D when  either  of
     the following
	happens:

	  * the managing unique_resource object is destroyed,
	  *  the  managing  unique_resource  object is assigned from another re-
     source via
	    operator= or reset().

	Let type RS be R if R is an object type, or
	std::reference_wrapper<std::remove_reference_t<R>> otherwise:

	  * unique_resource effectively holds a subobject of type RS which is or
     wraps the
	    resource handle, a deleter of type D  and  a  bool	flag  indicating
     whether the
	    wrapper is owning the resource.
	  *  For  explanatory purpose, the subobject of type RS is called stored
     resource
	    handle, and the stored (if R is an object type) or wrapped (if R  is
     a reference
	    type)  R  is  called underlying resource handle. These two terms are
     not used by
	    the LFTS.

Template parameters
	R		       -		     resource handle type
	D		       -		     deleter type

Type requirements
	-
	R shall be an object type or an lvalue reference to an object type.  Let
     UnrefR be
	std::remove_reference_t<R>,  UnrefR  shall  be MoveConstructible, and if
     UnrefR is not
	CopyConstructible, std::is_nothrow_move_constructible_v<UnrefR> shall be
     true.
	-
	D shall be a Destructible and MoveConstructible FunctionObject type, and
     if D is not
	CopyConstructible,  std::is_nothrow_move_constructible_v<D>   shall   be
     true. Given an
	lvalue	d  of type D and an lvalue r of type UnrefR, the expression d(r)
     shall be
	well-formed.

Member functions
	constructor   constructs a new unique_resource
		      (public member function)
	destructor    disposes the managed resource if such is present
		      (public member function)
	operator=     assigns a unique_resource
		      (public member function)

Modifiers
	release       releases the ownership
		      (public member function)
	reset	      disposes or replaces the managed resource
		      (public member function)

Observers
	get	      accesses the underlying resource handle
		      (public member function)
	get_deleter   accesses the deleter used for disposing of the managed re-
     source
		      (public member function)
	operator*     accesses the pointee if the resource handle is a pointer
	operator->    (public member function)

Non-member functions
	make_unique_resource_checked creates a unique_resource, checking invalid
     value
				     (function template)

	Deduction guides

Notes
	Resource handle types satisfying NullablePointer can also be managed by
	std::unique_ptr. Unlike unique_ptr, unique_resource does not require
	NullablePointer.

Example
	 This section is incomplete
	 Reason: no example

See also
	unique_ptr smart pointer with unique object ownership semantics
	(C++11)    (class template)

Category:
	  * Todo no example

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