C++11 std::bind std::function 高级用法

ゝ一纸荒年。 2022-06-12 07:51 101阅读 0赞

From: [ http://blog.csdn.net/eclipser1987/article/details/24406203][http_blog.csdn.net_eclipser1987_article_details_24406203]

从最基础的了解，std::bind和std::function

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

1.  /\* 
2.   \* File: main.cpp
3.   \* Author: Vicky.H
4.   \* Email: eclipser@163.com
5.   \*/
6.  \#include <iostream>
7.  \#include <functional>
8.  \#include <typeinfo>
9.  \#include <string.h>
10. 
11. int add1(int i, int j, int k) \{
12. return i + j + k;
13. \}
14. 
15. 
16. class Utils \{
17. public:
18. Utils(const char\* name) \{
19. strcpy(\_name, name);
20. \}
21. 
22. void sayHello(const char\* name) const \{
23. std::cout << \_name << " say: hello " << name << std::endl;
24. \}
25. 
26. static int getId() \{
27. return 10001;
28. \}
29. 
30. int operator()(int i, int j, int k) const \{
31. return i + j + k;
32. \}
33. 
34. private:
35. char \_name\[32\];
36. \};
37. 
38. 
39. /\*
40.  \* 
41.  \*/
42. int main(void) \{
43. 
44. // 绑定全局函数
45. auto add2 = std::bind(add1, std::placeholders::\_1, std::placeholders::\_2, 10);
46. // 函数add2 = 绑定add1函数，参数1不变，参数2不变，参数3固定为10.
47. std::cout << typeid(add2).name() << std::endl;
48. std::cout << "add2(1,2) = " << add2(1, 2) << std::endl;
49. 
50. std::cout << "\\n---------------------------" << std::endl;
51. 
52. // 绑定成员函数
53. Utils utils("Vicky");
54. auto sayHello = std::bind(&Utils::sayHello, utils/\*调用者\*/, std::placeholders::\_1/\*参数1\*/);
55. sayHello("Jack");
56. 
57. auto sayHelloToLucy = std::bind(&Utils::sayHello, utils/\*调用者\*/, "Lucy"/\*固定参数1\*/);
58. sayHelloToLucy();
59. 
60. // 绑定静态成员函数
61. auto getId = std::bind(&Utils::getId);
62. std::cout << getId() << std::endl;
63. 
64. std::cout << "\\n---------------------------" << std::endl;
65. 
66. // 绑定operator函数
67. auto add100 = std::bind(&Utils::operator (), utils, std::placeholders::\_1, std::placeholders::\_2, 100);
68. std::cout << "add100(1, 2) = " << add100(1, 2) << std::endl;
69. 
70. // 注意：无法使用std::bind()绑定一个重载函数
71. 
72. return 0;
73. \}

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

1.  /\* 
2.   \* File: main2.cpp
3.   \* Author: Vicky.H
4.   \* Email: eclipser@163.com
5.   \*/
6.  \#include <iostream>
7.  \#include <typeinfo>
8.  
9.  
10. void sayHello() \{
11. std::cout << "Hello world !" << std::endl;
12. \}
13. 
14. int sum(int i, int j, int k) \{
15. return i + j + k;
16. \}
17. 
18. template <typename T>
19. class Func \{
20. public:
21. 
22. Func(T fun) \{
23. if (!fun) \{
24. throw "fun nullptr";
25. \}
26. \_fun = fun;
27. \}
28. 
29. template<typename R, typename A1, typename A2, typename A3, typename A4, typename A5>
30. R Call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) \{
31. return \_fun(a1, a2, a3, a4, a5);
32. \}
33. 
34. template<typename R, typename A1, typename A2, typename A3, typename A4>
35. R Call(A1 a1, A2 a2, A3 a3, A4 a4) \{
36. return \_fun(a1, a2, a3, a4);
37. \}
38. 
39. template<typename R, typename A1, typename A2, typename A3>
40. R Call(A1 a1, A2 a2, A3 a3) \{
41. return \_fun(a1, a2, a3);
42. \}
43. 
44. template<typename R, typename A1, typename A2>
45. R Call(A1 a1, A2 a2) \{
46. return \_fun(a1, a2);
47. \}
48. 
49. template<typename R, typename A1>
50. R Call(A1 a1) \{
51. return \_fun(a1);
52. \}
53. 
54. template<typename R>
55. R Call() \{
56. return \_fun();
57. \}
58. 
59. void Call() \{
60. \_fun();
61. \}
62. 
63. private:
64. T \_fun;
65. \};
66. 
67. \#include <functional>
68. 
69. template<typename R = void, typename... Args>
70. class Fn \{
71. public:
72. Fn(std::function<R(Args...)> fun) : \_fun(fun) \{
73. \}
74. 
75. R operator()(Args... args) \{
76. return \_fun(args...);
77. \}
78. private:
79. std::function<R(Args...) > \_fun;
80. \};
81. 
82. /\*
83.  \* 将函数注册到对象中，通过对象直接调用
84.  \*/
85. int main(void) \{
86. 
87. 
88. Func<void(\*)() > sayHelloFunc(sayHello);
89. sayHelloFunc.Call();
90. 
91. 
92. Func<int (\*)(int, int, int) > sumFunc(sum);
93. std::cout << "sumFunc.Call<int>(1, 2, 3) : " << sumFunc.Call<int>(1, 2, 3) << std::endl;
94. 
95. 
96. std::cout << "\\n---------------------------" << std::endl;
97. 
98. Fn<> sayHelloFn(sayHello);
99. sayHelloFn();
100. 
101. Fn<int, int, int, int> sumFn(sum);
102. std::cout << "sumFn(1, 2, 3) : " << sumFn(1, 2, 3) << std::endl;
103. 
104. std::cout << "\\n---------------------------" << std::endl;
105. 
106. return 0;
107. \}

Hello world !  
sumFunc.Call<int>(1, 2, 3) : 6  
  
  
\---------------------------  
Hello world !  
sumFn(1, 2, 3) : 6  
  
  
\---------------------------

上面的例子非常有趣，使用了2种方案，将一个函数，注册到一个对象/仿函数中，并且通过一个对象/仿函数来直接调用调用。  
例子显而易见的，第2种方案更佳简洁，并且对传递参数有明确的判断，当参数类型或数量不正确的时候，编译器将导致失败。  
这种方案，可以将类的成员变量直接作为函数的参数使用，或者，如我：  
http://blog.csdn[.NET][]/eclipser1987/article/details/23926395  
这篇文章中，无法直接调用脚本函数类，有了好的解决办法。这个我将随后补充。

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

1.  \#include <list>
2.  \#include <functional>
3.  
4.  template<typename... Args>
5.  class Fns
6.  \{
7.  private:
8.  
9.  std::list<std::function<void(Args...)> > \_calls;
10. 
11. public:
12. 
13. virtual ~Fns()
14. \{
15. \_calls.clear();
16. \}
17. 
18. void connect(std::function<void(Args...)> fct)
19. \{
20. \_calls.push\_back(fct);
21. \}
22. 
23. template<typename Object>
24. void connect(Object\* object, void (Object::\*method)(Args...))
25. \{
26. \_calls.push\_back(\[object,method\](Args... args)\{(\*object.\*method)(args...);\});
27. \}
28. 
29. template<typename Object>
30. void connect(Object\* object, void (Object::\*method)(Args...) const)
31. \{
32. \_calls.push\_back(\[object,method\](Args... args)\{(\*object.\*method)(args...);\});
33. \}
34. 
35. template<typename Object>
36. void connect(const Object\* object, void (Object::\*method)(Args...) const)
37. \{
38. \_calls.push\_back(\[object,method\](Args... args)\{(\*object.\*method)(args...);\});
39. \}
40. 
41. void emit(Args... args)
42. \{
43. for(auto call : \_calls)
44. call(args...);
45. \}
46. \};

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

1.  \#include <cstdio>
2.  \#include "Signal.hpp"
3.  
4.  class Foo
5.  \{
6.  public:
7.  
8.  void bar(int x, int y)
9.  \{
10. printf("Foo::bar(%d, %d)\\n", x, y);
11. \}
12. \};
13. 
14. void foobar(int x, int y)
15. \{
16. printf("foobar(%d, %d)\\n", x, y);
17. \}
18. 
19. int main(void)
20. \{
21. Foo foo;
22. Fns<int, int> s;
23. 
24. // Connect a function
25. s.connect(foobar);
26. // Connect a class method
27. s.connect(&foo, &Foo::bar);
28. // Create and connect some lambda expression
29. s.connect(\[&foo\](int x, int y)\{
30. printf("lambda::"); foo.bar(x, y);
31. \});
32. // Emit the signal !
33. s.emit(4, 2);
34. getchar();
35. return 0;
36. \}

foobar(4, 2)  
Foo::bar(4, 2)  
lambda::Foo::bar(4, 2)

[http_blog.csdn.net_eclipser1987_article_details_24406203]: http://blog.csdn.net/eclipser1987/article/details/24406203
[view plain]: http://blog.csdn.net/eclipser1987/article/details/24406203#
[.NET]: http://lib.csdn.net/base/dotnet