Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

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
       resource
			(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 in-
       valid 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)

http://cppreference.com		  2022.07.31	  std::experi...ue_resource(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::experimental::unique_resource&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help