Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/named req/Callable"

From cppreference.com
< cpp‎ | named req
(See also: is_invocable)
m (link to zh)
Line 59: Line 59:
 
{{dsc inc | cpp/types/dsc is_invocable}}
 
{{dsc inc | cpp/types/dsc is_invocable}}
 
{{dsc end}}
 
{{dsc end}}
 +
 +
[[zh:cpp/concept/Callable]]

Revision as of 00:29, 20 March 2017

Template:cpp/concept/title Template:cpp/concept/navbar

A Template:concept type is a type for which the INVOKE operation (used by, e.g., std::function, std::bind, and std::thread::thread) is applicable. This operation may be performed explicitly using the library function std::invoke.(since C++17)

Contents

Requirements

The type T satisfies Callable if

Given

  • f, an object of type T
  • ArgTypes, suitable list of argument types
  • R, suitable return type

The following expressions must be valid:

Expression Requirements
INVOKE<R>(f, std::declval<ArgTypes>()...) the expression is well-formed in unevaluated context

where INVOKE<R>(f, t1, t2, ..., tN) is defined as static_cast<void>(INVOKE(f, t1, t2, ..., tN)) if R is possibly cv-qualified void, otherwise(since C++17) INVOKE(f, t1, t2, ..., tN), implicitly converted to R

where INVOKE(f, t1, t2, ..., tN) is defined as follows:

  • If std::is_base_of<T, std::decay_t<decltype(t1)>>::value is true, then INVOKE(f, t1, t2, ..., tN) is equivalent to (t1.*f)(t2, ..., tN)
  • otherwise, if std::decay_t<decltype(t1)> is a specialization of std::reference_wrapper, then INVOKE(f, t1, t2, ..., tN) is equivalent to (t1.get().*f)(t2, ..., tN)(since C++17)
  • otherwise, if t1 does not satisfy the previous items, then INVOKE(f, t1, t2, ..., tN) is equivalent to ((*t1).*f)(t2, ..., tN).
  • If std::is_base_of<T, std::decay_t<decltype(t1)>>::value is true, then INVOKE(f, t1) is equivalent to t1.*f
  • otherwise, if std::decay_t<decltype(t1)> is a specialization of std::reference_wrapper, then INVOKE(f, t1) is equivalent to t1.get().*f(since C++17)
  • otherwise, if t1 does not satisfy the previous items, then INVOKE(f, t1) is equivalent to (*t1).*f
  • otherwise, INVOKE(f, t1, t2, ..., tN) is equivalent to f(t1, t2, ..., tN) (that is, f is a Template:concept)

Notes

For pointers to member functions and pointers to data members, t1 may be a regular pointer or an object of class type that overloads operator*, such as std::unique_ptr or std::shared_ptr.

Pointers to data members are Callable, even though no function calls take place.

Standard library

In addition, the following standard library facilities accept any Template:concept type (not just Template:concept)

std::function
std::bind
std::result_of
std::thread::thread
std::call_once
std::async
std::packaged_task
std::reference_wrapper

See also

checks if a type can be invoked (as if by std::invoke) with the given argument types
(class template) [edit]