std::function<R(Args...)>::function
(until C++20)
function( F&& f );
function( std::allocator_arg_t, const Alloc& alloc ) noexcept;
(removed in C++17)
function( std::allocator_arg_t, const Alloc& alloc,
(removed in C++17)
function( std::allocator_arg_t, const Alloc& alloc,
(removed in C++17)
function( std::allocator_arg_t, const Alloc& alloc,
(removed in C++17)
function( std::allocator_arg_t, const Alloc& alloc, F f );
(removed in C++17)
Constructs a std::function
from a variety of sources.
std::function
specialization, *this will be empty right after the call.- std::is_same_v <std::remove_cvref_t <F>, std::function <R(Args...)> is false.
- An lvalue of type std::decay <F>::type is callable for argument types
Args...
and return typeR
.
If std::is_copy_constructible_v <std::decay_t <F>> or std::is_constructible_v <std::decay_t <F>, F> is false, the program is ill-formed.
(since C++23)F
is not CopyConstructible, the behavior is undefined.std::function
might use.When the target is a function pointer or a std::reference_wrapper , small object optimization is guaranteed, that is, these targets are always directly stored inside the std::function object, no dynamic allocation takes place. Other large objects may be constructed in dynamic allocated storage and accessed by the std::function object through a pointer.
[edit] Parameters
Alloc
must meet the requirements of Allocator.
[edit] Exceptions
[edit] Notes
std::function
's allocator support was poorly specified and inconsistently implemented. Some implementations do not provide overloads (6-10) at all, some provide the overloads but ignore the supplied allocator argument, and some provide the overloads and use the supplied allocator for construction but not when the std::function
is reassigned. As a result, allocator support was removed in C++17.
[edit] Example
#include <functional> #include <iostream> #include <utility> void print_num(int i) { std::cout << "print_num(" << i << ")\n"; } int main() { std::function <void(int)> func1; // (1) empty constructor try { func1(333 << 1); } catch (const std::bad_function_call & ex) { std::cout << "1) " << ex.what() << '\n'; } std::function <void(int)> func2{nullptr}; // (2) empty constructor try { func1(222 * 3); } catch (const std::bad_function_call & ex) { std::cout << "2) " << ex.what() << '\n'; } func1 = print_num; // initializes func1 using assignment operator std::function <void(int)> func3{func1}; // (3) copy constructor func3(33); std::function <void(int)> func4{std::move(func3)}; // (4) move constructor, // func3 in unspecified state func4(44); std::function <void(int)> func5{print_num}; // (5) constructor with function func5(55); // (5) constructor with lambda std::function <void(int)> func6([](int i) { std::cout << "lambda(" << i << ")\n"; }); func6(66); }
Possible output:
1) bad_function_call 2) bad_function_call print_num(33) print_num(44) print_num(55) lambda(66)
[edit] Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR | Applied to | Behavior as published | Correct behavior |
---|---|---|---|
LWG 2132 | C++11 | overloads (5,10) might be ambiguous | constrained |
LWG 2774 | C++11 | (5,10) performed an additional move | eliminated |
[edit] See also
std::move_only_function
object (public member function of
std::move_only_function
) [edit]