home | help 
std::move_only_function(3)     C++ Standard Libary    std::move_only_function(3)

NAME
     std::move_only_function - std::move_only_function

Synopsis
	Defined in header <functional>
	template<   class...   >				     (1)  (since
     C++23)
	class move_only_function; // not defined
	template< class R, class... Args >

	class move_only_function<R(Args...)>;
	template< class R, class... Args >
	class move_only_function<R(Args...) noexcept>;
	template< class R, class... Args >
	class move_only_function<R(Args...) &>;
	template< class R, class... Args >
	class move_only_function<R(Args...) & noexcept>;
	template< class R, class... Args >
	class move_only_function<R(Args...) &&>;
	template< class R, class... Args >
	class  move_only_function<R(Args...)  &&  noexcept>;	    (2)   (since
     C++23)
	template< class R, class... Args >
	class move_only_function<R(Args...) const>;
	template< class R, class... Args >
	class move_only_function<R(Args...) const noexcept>;
	template< class R, class... Args >
	class move_only_function<R(Args...) const &>;
	template< class R, class... Args >
	class move_only_function<R(Args...) const & noexcept>;
	template< class R, class... Args >
	class move_only_function<R(Args...) const &&>;
	template< class R, class... Args >

	class move_only_function<R(Args...) const && noexcept>;

	Class  template std::move_only_function is a general-purpose polymorphic
     function
	wrapper. std::move_only_function objects can store and invoke  any  con-
     structible (not
	required  to  be move constructible) Callable target a functions, lambda
     expressions,
	bind expressions, or other function objects, as well as pointers to mem-
     ber functions
	and pointers to member objects.

	The stored callable object is called the target of  std::move_only_func-
     tion. If a
	std::move_only_function contains no target, it is called empty. Unlike
	std::function,	invoking an empty std::move_only_function results in un-
     defined
	behavior.

	std::move_only_functions supports every possible combination of cv-qual-
     ifiers,
	ref-qualifiers, and noexcept-specifiers not including volatile	provided
     in its
	template parameter. These qualifiers and specifier (if any) are added to
     its
	operator().

	std::move_only_function  satisfies the requirements of MoveConstructible
     and
	MoveAssignable, but does not satisfy CopyConstructible	or  CopyAssigna-
     ble.

Member types
	Type	    Definition
	result_type R

Member functions
	constructor   constructs a new std::move_only_function object
	(C++23)       (public member function)
	destructor    destroys a std::move_only_function object
	(C++23)       (public member function)
	operator=     replaces or destroys the target
	(C++23)       (public member function)
	swap	      swaps the targets of two std::move_only_function objects
	(C++23)       (public member function)
	operator bool checks if the std::move_only_function has a target
	(C++23)       (public member function)
	operator()    invokes the target
	(C++23)       (public member function)

Non-member functions
	swap(std::move_only_function) overloads the std::swap algorithm
	(C++23) 		      (function)
	operator==		       compares  a  std::move_only_function with
     nullptr
	(C++23) 		      (function)

Notes
	Implementations may store a callable object of small size within the
	std::move_only_function object. Such small object optimization is effec-
     tively
	required for function pointers	and  std::reference_wrapper  specializa-
     tions, and can
	only   be   applied  to  types	T  for	which  std::is_nothrow_move_con-
     structible_v<T> is
	true.

	If a std::move_only_function returning a reference is initialized from a
     function or
	function object returning a prvalue (including a lambda expression with-
     out a
	trailing-return-type), the program is ill-formed because binding the re-
     turned
	reference to a temporary object is  forbidden.	See  also  std::function
     Notes.

	     Feature-test macro       Value    Std	     Feature
	__cpp_lib_move_only_function 202110L (C++23) std::move_only_function

Example
     // Run this code

      #include <functional>
      #include <future>
      #include <iostream>

      int main()
      {
	  std::packaged_task<double()> packaged_task([](){ return 3.14159; });

	  std::future<double> future = packaged_task.get_future();

	  auto lambda = [task = std::move(packaged_task)]() mutable { task(); };

      //  std::function<void()> function = std::move(lambda); // Error
	  std::move_only_function<void()> function = std::move(lambda); // OK

	  function();

	  std::cout << future.get();
      }

Output:
      3.14159

See also
	function wraps callable object of any copy constructible type with spec-
     ified
	(C++11)  function call signature
		 (class template)

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