std::function
定义在 <functional> 头文件
| template< class >
class function; /* undefined */ | (从C++11开始) | | template< class R, class... Args >
class function<R(Args...)>; | (从C++11开始) |
类模板std :: function是通用的多态函数包装器。 std :: function的实例可以存储，复制和调用任何Callable目标-函数，lambda表达式，bind表达式或其他函数对象，以及指向成员函数的指针和指向数据成员的指针。
存储的可调用对象称为std :: function的目标。 如果std :: function不包含目标，则称为空。 调用空std :: function的目标会导致引发std :: bad_function_call异常。
std :: function满足CopyConstructible和CopyAssignable的要求。
成员变量
| 类型 | 定义 | result_type | R | argument_type(deprecated in C++17)(removed in C++20) | T if sizeof...(Args)==1 and T is the first and only type in Args... | first_argument_type(deprecated in C++17)(removed in C++20) | T1 if sizeof...(Args)==2 and T1 is the first of the two types in Args... | second_argument_type(deprecated in C++17)(removed in C++20) | T2 if sizeof...(Args)==2 and T2 is the second of the two types in Args... |
成员函数
| （构造函数） | 构造一个新的std :: function实例
（公共成员函数） | | （析构函数） | 析构std :: function实例
（公共成员函数） | | operator= | 赋值一个新对象
（公共成员函数） | | swap | 交换内容
（公共成员函数） | | assign (removed in C++17) | 赋值一个新对象
（公共成员函数） | | operator bool | 检查是否包含有效目标
（公共成员函数） | | operator() | 调用目标
（公共成员函数） |
| 目标访问 | | target_type | 获取存储目标的typeid
（公共成员函数） | | target | 获取指向存储目标的指针（公共成员函数） |
非成员函数
| std::swap(std::function) (C++11) | 特化std::swap算法
(函数模板) | | operator==
operator!= (removed in C++20) | 比较std :: function和null
(函数模板) |
帮助类
| std::uses_allocator<std::function> (C++11)(until C++17) | 特化std::uses_allocator类型特征
(类模板特化) |
注意
从不带尾随返回类型的lambda表达式初始化其结果类型为引用的std :: function时应格外小心。 由于自动推论的工作方式，此类lambda表达式将始终返回prvalue。 因此，生成的引用通常将绑定到一个临时对象，该临时对象的生命周期将在std :: function :: operator（）返回时终止。
std::function<const int&()> F([]{ return 42; });
int x = F(); // Undefined behavior: the result of F() is a dangling reference
实例
#include <functional>
#include <iostream>
struct Foo {
Foo(int num) : num_(num) {}
void print_add(int i) const { std::cout << num_+i << '\n'; }
int num_;
};
void print_num(int i)
{
std::cout << i << '\n';
}
struct PrintNum {
void operator()(int i) const
{
std::cout << i << '\n';
}
};
int main()
{
// store a free function
std::function<void(int)> f_display = print_num;
f_display(-9);
// store a lambda
std::function<void()> f_display_42 = []() { print_num(42); };
f_display_42();
// store the result of a call to std::bind
std::function<void()> f_display_31337 = std::bind(print_num, 31337);
f_display_31337();
// store a call to a member function
std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;
const Foo foo(314159);
f_add_display(foo, 1);
f_add_display(314159, 1);
// store a call to a data member accessor
std::function<int(Foo const&)> f_num = &Foo::num_;
std::cout << "num_: " << f_num(foo) << '\n';
// store a call to a member function and object
using std::placeholders::_1;
std::function<void(int)> f_add_display2 = std::bind( &Foo::print_add, foo, _1 );
f_add_display2(2);
// store a call to a member function and object ptr
std::function<void(int)> f_add_display3 = std::bind( &Foo::print_add, &foo, _1 );
f_add_display3(3);
// store a call to a function object
std::function<void(int)> f_display_obj = PrintNum();
f_display_obj(18);
}
输出：
-9
42
31337
314160
314160
num_: 314159
314161
314162
18
| 
转播
