C++11 std::bind std::function 变参函数

Posted 同皆无穷小

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++11 std::bind std::function 变参函数相关的知识，希望对你有一定的参考价值。

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

[cpp] view plain copy
  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 copy
  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 copy
  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 copy
  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)

以上是关于C++11 std::bind std::function 变参函数的主要内容，如果未能解决你的问题，请参考以下文章

C++11新特性应用--实现延时求值(std::function和std::bind)

C++11 std::bind std::function 变参函数

C++11 std::bind std::function 变参函数

C++11之用std::function和std::bind实现观察者模式

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

C++11之std::bind感悟