std::experimental::packaged_task (library fundamentals TS)

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Technical specifications

Filesystem library (filesystem TS)

Library fundamentals (library fundamentals TS)

Library fundamentals 2 (library fundamentals 2 TS)

Extensions for parallelism (parallelism TS)

Concepts (concepts TS)

Extensions for concurrency (concurrency TS)

Special mathematical functions (special math TR)

 

Library fundamentals

experimental::optional

experimental::any

experimental::basic_string_view

experimental::sample

experimental::shared_ptr

experimental::weak_ptr

experimental::apply

experimental::invocation_type experimental::raw_invocation_type

experimental::search

experimental::default_searcher experimental::make_default_searcher

experimental::boyer_moore_searcher experimental::make_boyer_moore_searcher

experimental::boyer_moore_horspool_searcher experimental::make_boyer_moore_horspool_searcher

type-erased and polymorphic allocators

variable templates for type traits

 

Polymorphic allocator library

polymorphic_allocator

convenience aliases for containers using polymorphic_allocator

Memory resource classes

memory_resource

synchronized_pool_resource

unsynchronized_pool_resource

monotonic_buffer_resource

resource_adaptor

Global memory resources

new_delete_resource

null_memory_resource

get_default_resource

set_default_resource

Type-erased allocator support for existing classes

function

packaged_task

promise

 

This page is about the modified version of std::packaged_task with type-erased allocator support provided by the Library Fundamentals TSes. For the version of packaged_task provided by the concurrency TS supporting the std::future improvements made by that TS, see std::experimental::concurrency_v1::packaged_task.

Defined in header <experimental/future>
template< class > class packaged_task; //not defined	(1)	(library fundamentals TS)
template< class R, class ...Args > class packaged_task<R(Args...)>;	(2)	(library fundamentals TS)

std::experimental::fundamentals_v1::packaged_task (and std::experimental::fundamentals_v2::packaged_task) is a modified version of std::packaged_task provided by the library fundamentals TS with support for type-erased allocators.

Member types

Member type	Definition
allocator_type	std::experimental::erased_type

Member functions

(constructor)	constructs the task object (public member function)
get_memory_resource	retrieves a pointer to the memory resource used by this object to allocate memory (public member function)

Non-member function

std::experimental::swap(std::experimental::packaged_task)	specializes the swap algorithm (function template)

Helper classes

std::uses_allocator<std::experimental::packaged_task>	specializes the std::uses_allocator type trait (class template specialization)

Members identical to std::packaged_task

Member functions

(destructor)	destructs the task object (public member function of std::packaged_task)
operator=	moves the task object (public member function of std::packaged_task)
valid	checks if the task object has a valid function (public member function of std::packaged_task)
swap	swaps two task objects (public member function of std::packaged_task)
Getting the result
get_future	returns a std::future associated with the promised result (public member function of std::packaged_task)
Execution
operator()	executes the function (public member function of std::packaged_task)
make_ready_at_thread_exit	executes the function ensuring that the result is ready only once the current thread exits (public member function of std::packaged_task)
reset	resets the state abandoning any stored results of previous executions (public member function of std::packaged_task)