std：：function简介及模板类声明

01

—

std：：function简介

std：：function是一个函数包装器，该函数包装器模板能包装任何类型的可调用实体，如普通函数，函数对象，lamda表达式等。包装器可拷贝，移动等，并且包装器类型仅仅依赖于调用特征，而不依赖于可调用元素自身的类型。

std：：function是C++11的新特性，包含在头文件《functional》中。一个std：：function类型对象实例可以包装下列这几种可调用实体：函数、函数指针、成员函数、静态函数、lamda表达式和函数对象。

std：：function对象实例可被拷贝和移动，并且可以使用指定的调用特征来直接调用目标元素。当std：：function对象实例未包含任何实际可调用实体时，调用该std：：function对象实例将抛出std：：bad_function_call异常。02

—

std：：function实战

std：：function模板类声明

template《class _Rp， class 。。._ArgTypes》 class _LIBCPP_TEMPLATE_VIS function《_Rp（_ArgTypes.。。）》 ： public __function：：__maybe_derive_from_unary_function《_Rp（_ArgTypes.。。）》， public __function：：__maybe_derive_from_binary_function《_Rp（_ArgTypes.。。）》 { 。。. }std：：function模板类成员函数声明

typedef _Rp result_type; // construct/copy/destroy： _LIBCPP_INLINE_VISIBILITY function（） _NOEXCEPT { } _LIBCPP_INLINE_VISIBILITY function（nullptr_t） _NOEXCEPT {} function（const function&）; function（function&&） _NOEXCEPT; template《class _Fp， class = _EnableIfCallable《_Fp》》 function（_Fp）; #if _LIBCPP_STD_VER 《= 14 template《class _Alloc》 _LIBCPP_INLINE_VISIBILITY function（allocator_arg_t， const _Alloc&） _NOEXCEPT {} template《class _Alloc》 _LIBCPP_INLINE_VISIBILITY function（allocator_arg_t， const _Alloc&， nullptr_t） _NOEXCEPT {} template《class _Alloc》 function（allocator_arg_t， const _Alloc&， const function&）; template《class _Alloc》 function（allocator_arg_t， const _Alloc&， function&&）; template《class _Fp， class _Alloc， class = _EnableIfCallable《_Fp》》 function（allocator_arg_t， const _Alloc& __a， _Fp __f）; #endif function& operator=（const function&）; function& operator=（function&&） _NOEXCEPT; function& operator=（nullptr_t） _NOEXCEPT; template《class _Fp， class = _EnableIfCallable《_Fp》》 function& operator=（_Fp&&）; ~function（）; // function modifiers： void swap（function&） _NOEXCEPT; #if _LIBCPP_STD_VER 《= 14 template《class _Fp， class _Alloc》 _LIBCPP_INLINE_VISIBILITY void assign（_Fp&& __f， const _Alloc& __a） {function（allocator_arg， __a， _VSTD：：forward《_Fp》（__f））.swap（*this）;} #endif // function capacity： _LIBCPP_INLINE_VISIBILITY _LIBCPP_EXPLICIT operator bool（） const _NOEXCEPT { return static_cast《bool》（__f_）; } // deleted overloads close possible hole in the type system template《class _R2， class.。。 _ArgTypes2》 bool operator==（const function《_R2（_ArgTypes2.。。）》&） const = delete; template《class _R2， class.。。 _ArgTypes2》 bool operator！=（const function《_R2（_ArgTypes2.。。）》&） const = delete; public： // function invocation： _Rp operator（）（_ArgTypes.。。） const; #ifndef _LIBCPP_NO_RTTI // function target access： const std：：type_info& target_type（） const _NOEXCEPT; template 《typename _Tp》 _Tp* target（） _NOEXCEPT; template 《typename _Tp》 const _Tp* target（） const _NOEXCEPT; #endif // _LIBCPP_NO_RTTI从成员函数里我们知道std：：function对象实例不允许进行==和！=比较操作，std：：function模板类实例最终调用成员函数_Rp operator（）（_ArgTypes.。。） const进而调用包装的调用实体。1、std：：function包装函数指针定义一个std：：function《int（int）》对象实例

std：：function《int（int）》 callback;std：：function对象实例包装函数指针

int （*fun_ptr）（int）; int fun1（int a）{ return a; } int main（int argc， char *argv［］）{ std：：cout 《《 “Hello world” 《《 std：：endl; fun_ptr = fun1; //函数指针fun_ptr指向fun1函数 callback = fun_ptr; //std：：function对象包装函数指针 std：：cout 《《 callback（10） 《《 std：：endl; //std：：function对象实例调用包装的实体 return 0; }2、std：：function包装函数

int fun1（int a）{ return a; } int main（int argc， char *argv［］）{ std：：cout 《《 “Hello world” 《《 std：：endl; callback = fun1; //std：：function包装函数 std：：cout 《《 callback（42） 《《 std：：endl; //std：：function对象实例调用包装的调用实体 return 0; }3、std：：function包装模板函数

template《typename T》 T fun2（T a）{ return a + 2; } int main（int argc， char *argv［］）{ std：：cout 《《 “Hello world” 《《 std：：endl; callback = fun2《int》; //std：：function包装模板函数 std：：cout 《《 callback（10） 《《 std：：endl; //std：：function对象实例调用包装的调用实体 return 0; }4、std：：function包装函数对象

struct add{ int operator（）（int x）{ return x + 9; } }; int main（int argc， char *argv［］）{ std：：cout 《《 “Hello world” 《《 std：：endl; callback = add（）; //std：：function包装对象函数 std：：cout 《《 callback（2） 《《 std：：endl; //std：：function对象实例调用包装的调用实体 return 0; }5、std：：function包装lamda表达式

int main（int argc， char *argv［］）{ std：：cout 《《 “Hello world” 《《 std：：endl; auto fun3 = ［］（int a） {return a * 2;}; //lamda表达式 callback = fun3; //std：：function包装lamda表达式 std：：cout 《《 callback（9） 《《 std：：endl; //std：：function对象实例调用包装的调用实体 return 0; }

6、std：：function包装模板对象函数

template 《typename T》 struct sub{ T operator（）（T a）{ return a - 8; } }; int main（int argc， char *argv［］）{ std：：cout 《《 “Hello world” 《《 std：：endl; callback = sub《int》（）; //std：：function包装模板对象函数 std：：cout 《《 callback（2） 《《 std：：endl; //std：：function对象实例调用包装的调用实体 return 0; }

7、std：：function包装模板对象静态函数

template 《typename T》 struct foo2{ static T foo（T a）{ return a * 4; } }; int main（int argc， char *argv［］）{ std：：cout 《《 “Hello world” 《《 std：：endl; callback = foo2《int》：：foo; //std：：function包装模板对象静态函数 std：：cout 《《 callback（3） 《《 std：：endl; //std：：function对象实例调用包装的调用实体 return 0; }

8、std：：function包装对象静态函数

struct foo1{ static int foo（int a）{ return a * 3; } }; int main（int argc， char *argv［］）{ std：：cout 《《 “Hello world” 《《 std：：endl; callback = foo1：：foo; //std：：function包装对象静态函数 std：：cout 《《 callback（5） 《《 std：：endl; //std：：function对象实例调用包装的调用实体 return 0; }

9、std：：function包装类成员函数

struct foo3{ int foo（int a）{ return a * a; } }; int main（int argc， char *argv［］）{ std：：cout 《《 “Hello world” 《《 std：：endl; foo3 test_foo1; callback = std：：bind（&foo3：：foo， test_foo1， std：：_1）; //std：：function包装类成员函数 std：：cout 《《 callback（9） 《《 std：：endl; //std：：function对象实例调用包装的调用实体 return 0; }

这里我们用到了std：：bind，C++11中std：：bind函数的意义就如字面上的意思一样，用来绑定函数调用的某些参数。std：：bind的思想其实是一种延迟计算的思想，将可调用对象保存起来，然后在需要的时候再调用。而且这种绑定是非常灵活的，不论是普通函数还是函数对象还是成员函数都可以绑定，而且其参数可以支持占位符。

这里的std：：_1是一个占位符，且绑定第一个参数，若可调用实体有2个形参，那么绑定第二个参数的占位符是std：：_2。

10、std：：function包装模板类成员函数

template 《typename T》 struct foo4{ T foo（T a）{ return a * 6; } }; int main（int argc， char *argv［］）{ std：：cout 《《 “Hello world” 《《 std：：endl; foo4《int》 test_foo2; callback = std：：bind（&foo4《int》：：foo， test_foo2， std：：_1）; //std：：function包装模板类成员函数 std：：cout 《《 callback（7） 《《 std：：endl; //std：：function对象实例调用包装的调用实体 return 0; }

11、std：：function拷贝、移动

int main（int argc， char *argv［］）{ std：：cout 《《 “Hello world” 《《 std：：endl; std：：function《int（int）》 callback2 = callback; //拷贝赋值运算符 std：：cout 《《 callback2（7） 《《 std：：endl; std：：function《int（int）》&& callback3 = std：：move（callback）; //移动赋值运算符 std：：cout 《《 callback3（7） 《《 std：：endl; std：：cout 《《 callback（7） 《《 std：：endl; std：：function《int（int）》 callback4（callback）; //拷贝 std：：cout 《《 callback4（7） 《《 std：：endl; return 0; }

编辑：jq