std::function与std::bind 函数指针

蔚落 2022-06-16 09:12 111阅读 0赞

function模板类和bind模板函数，使用它们可以实现类似函数指针的功能，但却却比函数指针更加灵活，特别是函数指向类 的非静态成员函数时。

std::function可以绑定到全局函数/类静态成员函数(类静态成员函数与全局函数没有区别),如果要绑定到类的非静态成员函数，则需要使用std::bind。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#include <iostream>  
2.  \#include <functional>  
3.  **using** **namespace** std;  
4.    
5.  **typedef** std::function<**void** ()> fp;  
6.  **void** g\_fun()  
7.  \{  
8.      cout<<"g\_fun()"<<endl;  
9.  \}  
10. **class** A  
11. \{  
12. **public**:  
13.     **static** **void** A\_fun\_static()  
14.     \{  
15.         cout<<"A\_fun\_static()"<<endl;  
16.     \}  
17.     **void** A\_fun()  
18.     \{  
19.         cout<<"A\_fun()"<<endl;  
20.     \}  
21.     **void** A\_fun\_int(**int** i)  
22.     \{  
23.         cout<<"A\_fun\_int() "<<i<<endl;  
24.     \}  
25.   
26.     //非静态类成员，因为含有this指针，所以需要使用bind  
27.     **void** init()  
28.     \{  
29.         fp fp1=std::bind(&A::A\_fun,**this**);  
30.         fp1();  
31.     \}  
32.   
33.     **void** init2()  
34.     \{  
35.         **typedef** std::function<**void** (**int**)> fpi;  
36.         //对于参数要使用占位符 std::placeholders::\_1  
37.         fpi f=std::bind(&A::A\_fun\_int,**this**,std::placeholders::\_1);  
38.         f(5);  
39.     \}  
40. \};  
41. **int** main()  
42. \{  
43.     //绑定到全局函数  
44.     fp f2=fp(&g\_fun);  
45.     f2();  
46.   
47.     //绑定到类静态成员函数  
48.     fp f1=fp(&A::A\_fun\_static);  
49.     f1();  
50.   
51.     A().init();  
52.     A().init2();  
53.     **return** 0;  
54. \}

同时，std::bind绑定到虚函数时会表现出多态行为。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#include <iostream>  
2.  \#include <functional>  
3.  **using** **namespace** std;  
4.    
5.  **typedef** std::function<**void** ()> fp;  
6.    
7.  **class** A  
8.  \{  
9.  **public**:  
10.     **virtual** **void** f()  
11.     \{  
12.         cout<<"A::f()"<<endl;  
13.     \}  
14.   
15.     **void** init()  
16.     \{  
17.         //std::bind可以表现出多态行为  
18.         fp f=std::bind(&A::f,**this**);  
19.         f();  
20.     \}  
21. \};  
22. **class** B:**public** A  
23. \{  
24. **public**:  
25.     **virtual** **void** f()  
26.     \{  
27.         cout<<"B::f()"<<endl;  
28.     \}  
29. \};  
30. **int** main()  
31. \{  
32.     A\* pa=**new** B;  
33.     pa->init();  
34.   
35.     **return** 0;  
36. \}

写在最后：如果要实现类似网络消息派发功能。可以预先使用 HashMap 保存好 classnamekey和 类对象的映射关系。等网络消息过来后包括（classnamekey，funnamekey），通过classnamekey找到类对象。然后转调类对象的固定方法，（在类对象初始化时使用 HashMap保存好funnamekey 和 类内部函数的映射关系） ，在类对象固定方法内根据  funnamekey 找到对应类的内部函数，然后可以调用类对象的函数。

[view plain]: http://blog.csdn.net/qq575787460/article/details/8531397#