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

FreeBSD Manual Pages

  
 
  

home | help 
std::packag...ackaged_task(3) C++ Standard Libarystd::packag...ackaged_task(3)

NAME
       std::packaged_task::packaged_task - std::packaged_task::packaged_task

Synopsis
	  packaged_task()					     noexcept;
       (1) (since C++11)
	  template			    <class			    F>
       (2) (since C++11)
	  explicit packaged_task( F&& f	);
	  template	    <class	   F,	      class	    Allocator>
       (since C++11)
	  explicit packaged_task( std::allocator_arg_t,	 const	Allocator&  a,
       (3) (until C++17)
	  F&& f	);
	  packaged_task(      const	packaged_task&	   )	 =     delete;
       (4) (since C++11)
	  packaged_task(      packaged_task&&	   rhs	     )	     noexcept;
       (5) (since C++11)

	  Constructs a new std::packaged_task object.

	  1) Constructs	a std::packaged_task object with no task and no	shared
       state.
	  2,3)	Constructs a std::packaged_task	object with a shared state and
       a copy of the
	  task,	initialized with std::forward<F>(f).
	  The allocator	a is used to allocate memory necessary	to  store  the
       task.
	  (until C++17)

	    * These constructors do not
	      (until C++17)
	      This constructor does not
	      (since  C++17)  participate  in  overload	resolution if std::de-
       cay<F>::type is the
	      same type	as std::packaged_task<R(ArgTypes...)>.
	    * The program is ill-formed	if the INVOKE<R>(std::forward<F>(f),
	      std::declval<Args>()...) expression (described in	 Callable)  is
       ill-formed when
	      treated as an unevaluated	operand
	      (i.e. std::is_invocable_r_v<R, F,	Args...> is not	true)
	      (since C++17).
	    *  The  behavior is	undefined if the invocation on a copy of f be-
       haves different
	      from that	on f.

	  4) The copy constructor is deleted, std::packaged_task is move-only.
	  5) Constructs	a std::packaged_task with the shared  state  and  task
       formerly	owned by
	  rhs, leaving rhs with	no shared state	and a moved-from task.

Parameters
	  f   -	the callable target (function, member function,	lambda-expres-
       sion, functor) to
		execute
	  a   -	the allocator to use when storing the task
	  rhs -	the std::packaged_task to move from

Exceptions
	  2)  Any exceptions thrown by copy/move constructor of	f and possibly
       std::bad_alloc
	  if the allocation fails.
	  3) Any exceptions thrown by copy/move	constructor of f  and  by  the
       allocator's
	  allocate function if memory allocation fails.

Example
       // Run this code

	#include <future>
	#include <iostream>
	#include <thread>

	int fib(int n)
	{
	    if (n < 3) return 1;
	    else return	fib(n-1) + fib(n-2);
	}

	int main()
	{
	    std::packaged_task<int(int)> fib_task(&fib);

	    std::cout << "starting task\n";
	    auto result	= fib_task.get_future();
	    std::thread	t(std::move(fib_task), 42);

	    std::cout << "waiting for task to finish..." << std::endl;
	    std::cout << result.get() << '\n';

	    std::cout << "task complete\n";
	    t.join();
	}

Output:
	starting task
	waiting	for task to finish...
	267914296
	task complete

	 Defect	reports

	  The following	behavior-changing defect reports were applied retroac-
       tively to
	  previously published C++ standards.

	     DR	      Applied	 to		    Behavior	as   published
       Correct behavior
	  LWG 2067 C++11      the deleted copy constructor took	 reference  to
       made const
			      non-const

http://cppreference.com		  2022.07.31	 std::packag...ackaged_task(3)

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

home | help