15 KiB
[func.wrap.func]
22 General utilities library [utilities]
22.10 Function objects [function.objects]
22.10.17 Polymorphic function wrappers [func.wrap]
22.10.17.3 Class template function [func.wrap.func]
22.10.17.3.1 General [func.wrap.func.general]
namespace std {template<class R, class... ArgTypes>class function<R(ArgTypes...)> {public:using result_type = R; // [func.wrap.func.con], construct/copy/destroy function() noexcept; function(nullptr_t) noexcept; function(const function&); function(function&&) noexcept; template function(F&&);
function& operator=(const function&); function& operator=(function&&); function& operator=(nullptr_t) noexcept; template function& operator=(F&&); template function& operator=(reference_wrapper) noexcept; ~function(); // [func.wrap.func.mod], function modifiersvoid swap(function&) noexcept; // [func.wrap.func.cap], function capacityexplicit operator bool() const noexcept; // [func.wrap.func.inv], function invocation R operator()(ArgTypes...) const; // [func.wrap.func.targ], function target accessconst type_info& target_type() const noexcept; template T* target() noexcept; template const T* target() const noexcept; }; template<class R, class... ArgTypes> function(R(*)(ArgTypes...)) -> function<R(ArgTypes...)>; template function(F) -> function<see below>;}
The function class template provides polymorphic wrappers that generalize the notion of a function pointer.
Wrappers can store, copy, and call arbitrary callable objects ([func.def]), given a call signature ([func.def]).
The function class template is a call wrapper ([func.def]) whose call signature ([func.def]) is R(ArgTypes...).
[Note 1:
The types deduced by the deduction guides for function might change in future revisions of C++.
â end note]
22.10.17.3.2 Constructors and destructor [func.wrap.func.con]
function() noexcept;
Postconditions: !*this.
function(nullptr_t) noexcept;
Postconditions: !*this.
function(const function& f);
Postconditions: !*this if !f; otherwise, the target object of *this is a copy of the target object of f.
Throws: Nothing if f's target is a specialization of reference_wrapper or a function pointer.
Otherwise, may throw bad_alloc or any exception thrown by the copy constructor of the stored callable object.
Recommended practice: Implementations should avoid the use of dynamically allocated memory for small callable objects, for example, wheref's target is an object holding only a pointer or reference to an object and a member function pointer.
function(function&& f) noexcept;
Postconditions: If !f, *this has no target; otherwise, the target of *this is equivalent to the target of f before the construction, andf is in a valid state with an unspecified value.
Recommended practice: Implementations should avoid the use of dynamically allocated memory for small callable objects, for example, where f's target is an object holding only a pointer or reference to an object and a member function pointer.
template<class F> function(F&& f);
Let FD be decay_t.
Constraints:
is_same_v<remove_cvref_t, function> is false, and
is_invocable_r_v<R, FD&, ArgTypes...> is true.
Mandates:
is_copy_constructible_v is true, and
is_constructible_v<FD, F> is true.
Preconditions: FD meets the Cpp17CopyConstructible requirements.
Postconditions: !*this is true if any of the following hold:
-
f is a null function pointer value.
-
f is a null member pointer value.
-
remove_cvref_t is a specialization of the function class template, and!f is true.
Otherwise, *this has a target object of type FD direct-non-list-initialized with std::forward(f).
Throws: Nothing if FD is a specialization of reference_wrapper or a function pointer type.
Otherwise, may throw bad_alloc or any exception thrown by the initialization of the target object.
Recommended practice: Implementations should avoid the use of dynamically allocated memory for small callable objects, for example, where f refers to an object holding only a pointer or reference to an object and a member function pointer.
template<class F> function(F) -> function<see below>;
Constraints: &F::operator() is well-formed when treated as an unevaluated operand and either
F::operator() is a non-static member function anddecltype(&F::operator()) is either of the formR(G::*)(A...) cv &opt noexceptopt or of the formR(*)(G, A...) noexceptopt for a type G, or
F::operator() is a static member function anddecltype(&F::operator()) is of the formR(*)(A...) noexceptopt.
Remarks: The deduced type is function<R(A...)>.
[Example 1: void f() {int i{5}; function g = & { return i; }; // deduces function<int(double)>} â end example]
function& operator=(const function& f);
Effects: As if by function(f).swap(*this);
Returns: *this.
function& operator=(function&& f);
Effects: Replaces the target of *this with the target of f.
Returns: *this.
function& operator=(nullptr_t) noexcept;
Effects: If *this != nullptr, destroys the target of this.
Postconditions: !(*this).
Returns: *this.
template<class F> function& operator=(F&& f);
Constraints: is_invocable_r_v<R, decay_t&, ArgTypes...> is true.
Effects: As if by: function(std::forward(f)).swap(*this);
Returns: *this.
template<class F> function& operator=(reference_wrapper<F> f) noexcept;
Effects: As if by: function(f).swap(*this);
Returns: *this.
~function();
Effects: If *this != nullptr, destroys the target of this.
22.10.17.3.3 Modifiers [func.wrap.func.mod]
void swap(function& other) noexcept;
Effects: Interchanges the target objects of *this and other.
22.10.17.3.4 Capacity [func.wrap.func.cap]
explicit operator bool() const noexcept;
Returns: true if *this has a target, otherwise false.
22.10.17.3.5 Invocation [func.wrap.func.inv]
R operator()(ArgTypes... args) const;
Returns: INVOKE(f, std::forward(args)...) ([func.require]), where f is the target object ([func.def]) of *this.
Throws: bad_function_call if !*this; otherwise, any exception thrown by the target object.
22.10.17.3.6 Target access [func.wrap.func.targ]
const type_info& target_type() const noexcept;
Returns: If *this has a target of type T, typeid(T); otherwise, typeid(void).
template<class T> T* target() noexcept; template<class T> const T* target() const noexcept;
Returns: If target_type() == typeid(T) a pointer to the stored function target; otherwise a null pointer.
22.10.17.3.7 Null pointer comparison operator functions [func.wrap.func.nullptr]
template<class R, class... ArgTypes> bool operator==(const function<R(ArgTypes...)>& f, nullptr_t) noexcept;
Returns: !f.
22.10.17.3.8 Specialized algorithms [func.wrap.func.alg]
template<class R, class... ArgTypes> void swap(function<R(ArgTypes...)>& f1, function<R(ArgTypes...)>& f2) noexcept;
Effects: As if by: f1.swap(f2);