boost::bind 详解

最新推荐文章于 2023-02-10 13:29:59 发布
最新推荐文章于 2023-02-10 13:29:59 发布
阅读量3k 收藏 8
点赞数
分类专栏： C/C++ boost
C/C++ 同时被 2 个专栏收录
83 篇文章 7 订阅
订阅专栏
boost
13 篇文章 3 订阅
订阅专栏

https://zh.cppreference.com/w/cpp/utility/functional/bind

https://thispointer.com/c11-lambda-how-to-capture-local-variables-inside-lambda/

http://www.xumenger.com/cpp-boost-bind-function-20180612/

 

使用

boost::bind是标准库函数std::bind1st和std::bind2nd的一种泛化形式。其可以支持函数对象、函数、函数指针、成员函数指针，并且绑定任意参数到某个指定值上或者将输入参数传入任意位置。

1. 通过functions和function pointers使用bind

给定如下函数：

int f(int a, int b)
{
    return a + b;
}

int g(int a, int b, int c)
{
    return a + b + c;
}

可以绑定所有参数，如：

    bind(f, 1, 2)等价于f(1, 2); bind(g, 1, 2, 3)等价于g(1, 2, 3);

也可以选择性地绑定参数，如：

对于 _1, _2, _3:
    要绑定的参数列表，未绑定参数为命名空间 std::placeholders的占位符 _1, _2, _3...bind(f, _1, 5)(x)                  //等价于f(x, 5)，其中_1是一个占位符，表示用第一个参数来替换;
bind(f, _2, _1)(x, y)                  //等价于f(y, x);
bind(g, _1, 9, _1)(x)                 //等价于g(x, 9, x);
bind(g, _3, _3, _3)(x, y, z)       //等价于g(z, z, z);

说明：

传入bind函数的参数一般为变量的copy，如：

int i = 5;

bind(f, i, _1);

如果想传入变量的引用，可以使用boost::ref和boost::cref，如：

int i = 5;

bind(f, ref(i), _1);

bind(f, cref(i), _1);

 

2. 通过function objects使用bind

struct F
{
    int operator()(int a, int b) { return a – b; }
    bool operator()(long a, long b) { return a == b; }
};

F f;
int x = 100;
bind<int>(f, _1, _1)(x);        // f(x, x)

可能某些编译器不支持上述的bind语法，可以用下列方式代替：

boost::bind(boost::type<int>(), f, _1, _1)(x);

默认情况下，bind拥有的是函数对象的副本，但是也可以使用boost::ref和boost::cref来传入函数对象的引用，尤其是当该function object是non-copyable或者expensive to copy。

 

3. 通过pointers to members使用bind

bind将传入的成员（数据成员和成员函数）指针作为第一个参数，其行为如同使用boost::mem_fn将成员指针转换为一个函数对象，即：

bind(&X::f, args);       等价于bind<R>(mem_fn(&X::f), args)，其中R为X::f的返回类型（成员函数）或类型（数据成员）。

 struct X
 {
     bool f(int a);
 };

 X x;
 shared_ptr<X> p(new X);
 int i = 5;
 
 bind(&X::f, ref(x), _1)(i);        // x.f(i)
 bind(&X::f, &x, _1)(i);            // (&x)->f(i)
 bind(&X::f, x, _1)(i);            // x.f(i)
 bind(&X::f, p, _1)(i);            // p->f(i)

 

4. 使用nested binds

如bind(f, bind(g, _1))(x)中：

在外部bind计算之前，内部bind先被计算（如果内部有多个bind，则计算顺序不定）。如上，根据参数x，先计算bind(g, _1)(x)，生成g(x)，然后计算bind(f, g(x))(x)，最后生成f(g(x))。

 

但是要注意：

bind中的第一个参数不参与计算过程，假设如下程序想要实现对于向量v中的每个函数指针，传入一个参数 5：

typedef void (*pf)(int);

std::vector<pf> v;

std::for_each(v.begin(), v.end(), bind(_1, 5));

上述程序并没有实现我们想要的结果：可以通过使用一个帮助函数对象apply，该对象可以将bind的第一个参数作为一个函数对象，如下：

typedef void (*pf)(int);

std::vector<pf> v;

std::for_each(v.begin(), v.end(), bind(apply<void>(), _1, 5));

其中，apply实现如下：

 template<class R> 
 struct apply
 {
     typedef R result_type;
     template<class F> result_type operator()(F & f) const
     {
         return f();
     }
 ...
 };

 

示例程序

   // bind_test.cc
   #include <boost/config.hpp>
   
   #if defined(BOOST_MSVC)
   #pragma warning(disable: 4786)  // identifier truncated in debug info
   #pragma warning(disable: 4710)  // function not inlined
   #pragma warning(disable: 4711)  // function selected for automatic inline expansion
   #pragma warning(disable: 4514)  // unreferenced inline removed
   #endif
  
  #include <boost/bind.hpp>
  #include <boost/ref.hpp>
  
  #if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
  #pragma warning(push, 3)
  #endif
  
  #include <iostream>
  
  #if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
  #pragma warning(pop)
  #endif
  
  #include <boost/detail/lightweight_test.hpp>
  
  //
  long f_0() { return 17041L; }
  long f_1(long a) { return a; }
  long f_2(long a, long b) { return a + 10 * b; }
  
  
  long global_result;
  
  void fv_0() { global_result = 17041L; }
  void fv_1(long a) { global_result = a; }
  void fv_2(long a, long b) { global_result = a + 10 * b; }
  
  void function_test()
  {
      using namespace boost;
  
      int const i = 1;
  
      BOOST_TEST( bind(f_0)(i) == 17041L );
      BOOST_TEST( bind(f_1, _1)(i) == 1L );
      BOOST_TEST( bind(f_2, _1, 2)(i) == 21L );
  
      BOOST_TEST( (bind(fv_0)(i), (global_result == 17041L)) );
      BOOST_TEST( (bind(fv_1, _1)(i), (global_result == 1L)) );
      BOOST_TEST( (bind(fv_2, _1, 2)(i), (global_result == 21L)) );
  }
  
  
  //
  struct Y
  {
      short operator()(short & r) const { return ++r; }
      int operator()(int a, int b) const { return a + 10 * b; }
  };
  
  void function_object_test()
  {
      using namespace boost;
      short i(6);
  
      BOOST_TEST( bind<short>(Y(), ref(i))() == 7 );
      BOOST_TEST( bind(type<short>(), Y(), ref(i))() == 8 );
  }
  
  
  //
  struct X
  {
      mutable unsigned int hash;
  
      X(): hash(0) {}
  
      int f0() { f1(17); return 0; }
      int g0() const { g1(17); return 0; }
  
      int f1(int a1) { hash = (hash * 17041 + a1) % 32768; return 0; }
      int g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; return 0; }
  
      int f2(int a1, int a2) { f1(a1); f1(a2); return 0; }
      int g2(int a1, int a2) const { g1(a1); g1(a2); return 0; }
  };
  
  void member_function_test()
  {
      using namespace boost;
  
      X x;
  
      // 0
      bind(&X::f0, &x)();
      bind(&X::f0, ref(x))();
      bind(&X::g0, &x)();
      bind(&X::g0, x)();
      bind(&X::g0, ref(x))();
 
     // 1
     bind(&X::f1, &x, 1)();
     bind(&X::f1, ref(x), 1)();
     bind(&X::g1, &x, 1)();
     bind(&X::g1, x, 1)();
     bind(&X::g1, ref(x), 1)();
 
     // 2
 
     bind(&X::f2, &x, 1, 2)();
     bind(&X::f2, ref(x), 1, 2)();
     bind(&X::g2, &x, 1, 2)();
     bind(&X::g2, x, 1, 2)();
     bind(&X::g2, ref(x), 1, 2)();
 }
 
 void nested_bind_test()
 {
     using namespace boost;
 
     int const x = 1;
     int const y = 2;
 
     BOOST_TEST( bind(f_1, bind(f_1, _1))(x) == 1L );
     BOOST_TEST( bind(f_1, bind(f_2, _1, _2))(x, y) == 21L );
 }
 
 int main()
 {
     function_test();
     function_object_test();
     member_function_test();
     nested_bind_test();
 
     return boost::report_errors();
 }
 
 //output
 No errors detected.

 

易错点

1. 参数个数不正确

 int f(int, int);
 
 int main()
 {
     boost::bind(f, 1);    // error, f takes two arguments
     boost::bind(f, 1, 2); // OK
 }
 一个此类错误的变形为：忘记成员函数有一个隐式参数this:
 struct X
 {
     int f(int);
 }
 
 int main()
 {
     boost::bind(&X::f, 1);     // error, X::f takes two arguments
     boost::bind(&X::f, _1, 1); // OK
 }

2. 函数对象不能被指定参数调用

int f(int);

int main()
{
    boost::bind(f, "incompatible");      // OK so far, no call
    boost::bind(f, "incompatible")();    // error, "incompatible" is not an int
    boost::bind(f, _1);                   // OK
    boost::bind(f, _1)("incompatible");  // error, "incompatible" is not an int
}

3. 访问不存在的参数

//占位符_N需要在调用时从指定的参数表中选择第N个参数：
int f(int);

int main()
{
    boost::bind(f, _1);                  // OK
    boost::bind(f, _1)();                // error, there is no argument number 1
}

4. bind(f, ...)形式和bind<R>(f, ...)形式的不当用法

1 bind(f, a1, a2, ..., aN)会对f自动进行类型识别，f必须是一个函数或者成员函数指针。当f是函数对象时，大多数编译器将不能工作。
2 bind<R>(f, a1, a2, ..., aN)支持任意类型的函数对象。虽然在有些编译器上，传入函数或者成员函数指针也能工作，但是不推荐这么做。

5. 绑定一个非标准函数

1 bind(f, a1, a2, ..., aN)形式识别<普通的>C++函数和成员函数指针。如果一个函数使用了不同的调用约定或者可变参数列表（如std::printf），那么bind(f, a1, a2, ..., aN)将不能工作；如果确实需要使用此类非标准函数，那么bind<R>(f, a1, a2, ..., aN)将能满足这种要求。

6. 绑定一个重载函数

通常情况下，bind一个重载函数会导致错误，因为无法确定到底bind重载函数的哪个形式：
struct X
{
    int& get();
    int const& get() const;
};

int main()
{
    boost::bind(&X::get, _1);
}
这种二义性可以通过将成员函数指针转换到特定类型来解决：
int main()
{
    boost::bind(static_cast< int const& (X::*) () const >(&X::get), _1);
}
此外，一个更可具可读性的解决办法为引入一个临时变量：

int main()
{
    int const& (X::*get) () const = &X::get;
    boost::bind(get, _1);
}

7. boost的特定编译器实现问题

// 7.1 MSVC 6.0编译器
在函数签名中不支持const：（移除const就可以了）
int f(int const);

int main()
{
    boost::bind(f, 1);     // error
}
// 7.2 MSVC 7.0以下编译器
(1) 如果通过using声明引入boost::bind，如：using boost::bind，那么bind<R>(f, ...)语法将不能工作。
解决办法为直接使用限定名boost::bind或者使用using指令：using namespace boost;
(2) 一个嵌套的命名为bind的类模板将隐藏函数模板boost::bind，使得bind<R>(f, ...)语法不能工作。
(3) MSVC将可变参数中的省略号看作一种类型，因此，其可以接受如下形式：
bind(printf, "%s\n", _1);
但是拒绝正确的形式如：
bind<int>(printf, "%s\n", _1);

 

调用约定

根据调用约定的不同，不同的平台可能支持几种类型的（成员）函数。例如：

Windows API函数和COM接口成员函数使用__stdcall;

Borland VCL使用__fastcall;

Mac toolbox函数使用pascal。

与__stdcall函数一起使用bind时，在包含<boost/bind.hpp>之前#define the macro BOOST_BIND_ENABLE_STDCALL;

与__stdcall成员函数一起使用bind时，在包含<boost/bind.hpp>之前#define the macro BOOST_MEM_FN_ENABLE_STDCALL;

与__fastcall函数一起使用bind时，在包含<boost/bind.hpp>之前#define the macro BOOST_BIND_ENABLE_ FASTCALL;

与__fastcall成员函数一起使用bind时，在包含<boost/bind.hpp>之前#define the macro BOOST_MEM_FN_ENABLE_ FASTCALL;

与pascal函数一起使用bind时，在包含<boost/bind.hpp>之前#define the macro BOOST_BIND_ENABLE_ PASCAL;

与__cdecl成员函数一起使用bind时，在包含<boost/bind.hpp>之前#define the macro BOOST_MEM_FN_ENABLE_CDECL;

一个比较好的建议是：如果需要使用bind，要么提前在工程选项中定义这些宏，要么通过命令行选项-D定义，要么直接在使用bind的.cc文件中定义。否则如果包含bind.hpp的文件中，发生了在定义这些宏之前including bind.hpp，那么可能导致难以发现的错误。

#################

C++11 Lambda : How to capture local variables inside Lambda ?

Varun May 20, 2017 C++11 Lambda : How to capture local variables inside Lambda ?2017-05-20T22:53:12+05:30C++, C++ 11, lambda 3 Comments

In this article we will discuss how to capture local variables from outer scope in Lambda.

 

A simple Lambda syntax is,

 

1

[Captured variables](paameters) { function code }

Local variables from outer scope can be captured inside Lambda in 2 modes i.e.

  1. By Value
  2. By Reference

Capturing Local Variables by value inside Lambda Function

To capture the local variables by value, specify their name in capture list i.e.

 

1

2

3

4

5

6

7

8

9

// Local Variables

std::string msg = "Hello";

int counter = 10;

 

// Defining Lambda function and

// Capturing Local variables by Value

auto func = [msg, counter] () {

                          //...

                          };

Now, the variables specified in capture list will be copied inside lambda by value. Inside lambda they can be accessed but can not be changed, because they are const.

To modify the we need to add mutable keyword i.e.

 

1

auto func = [msg, counter] () mutable { };

Now the captured variables can be modified. But their modification will not affect value of outer scope variables, because they are captured by value.

Checkout this example,

 

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

#include <iostream>

#include <string>

 

int main(int argc, char **argv)

{

std::string msg = "Hello";

int counter = 10;

 

// Defining Lambda function and

// Capturing Local variables by Value

auto func = [msg, counter]  () mutable {

std::cout<<"Inside Lambda :: msg = "<<msg<<std::endl;

std::cout<<"Inside Lambda :: counter = "<<counter<<std::endl;

 

// Change the counter & msg

// Change will not affect the outer variable because counter variable is

// captured by value in Lambda function

msg = "Temp";

counter = 20;

 

std::cout<<"Inside Lambda :: After changing :: msg = "<<msg<<std::endl;

std::cout<<"Inside Lambda :: After changing :: counter = "<<counter<<std::endl;

 

};

 

//Call the Lambda function

func();

 

//Values of local variables are not changed.

std::cout<<"msg = "<<msg<<std::endl;

std::cout<<"counter = "<<counter<<std::endl;

 

return 0;

}

Output:

 

1

2

3

4

5

6

Inside Lambda :: msg = Hello

Inside Lambda :: counter = 10

Inside Lambda :: After changing :: msg = Temp

Inside Lambda :: After changing :: counter = 20

msg = Hello

counter = 10

 

Capturing Local Variables by Reference inside Lambda

To capture the local variables by reference, specify their name in capture list with prefix & i.e.

 

1

2

3

4

5

6

7

8

9

// Local Variables

std::string msg = "Hello";

int counter = 10;

 

// Defining Lambda function and

// Capturing Local variables by Reference

auto func = [&msg, &counter] () {

                       //...

                       };

Now, the variables specified in capture list will be captured inside lambda by Reference. Inside lambda they can be accessed and their value can also be changed. Also, their modification will affect value of outer scope variables, because they are captured by Reference.

Checkout this example,

 

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

#include <iostream>

#include <string>

 

int main(int argc, char **argv)

{

std::string msg = "Hello";

int counter = 10;

 

// Defining Lambda function and

// Capturing Local variables by Reference

auto func = [&msg, &counter]  () {

std::cout<<"Inside Lambda :: msg = "<<msg<<std::endl;

std::cout<<"Inside Lambda :: counter = "<<counter<<std::endl;

 

// Change the counter & msg

// Change will affect the outer variable because counter variable is

// captured by Reference in Lambda function

msg = "Temp";

counter = 20;

 

std::cout<<"Inside Lambda :: After changing :: msg = "<<msg<<std::endl;

std::cout<<"Inside Lambda :: After changing :: counter = "<<counter<<std::endl;

 

};

 

//Call the Lambda function

func();

 

std::cout<<"msg = "<<msg<<std::endl;

std::cout<<"counter = "<<counter<<std::endl;

 

return 0;

}

Output:

 

1

2

3

4

5

6

Inside Lambda :: msg = Hello

Inside Lambda :: counter = 10

Inside Lambda :: After changing :: msg = Temp

Inside Lambda :: After changing :: counter = 20

msg = Temp

counter = 20

 

Capture All Local Variables from outer scope by Value

To capture all local variables from outer scope by value, pass “=” in the capture list i.e.

 

1

2

3

4

// Capturing all Local variables by Value

auto func = [=] () {

                   //...

                   };

 

Capture all local variables from outer scope by Reference

To capture all local variables from outer scope by Reference, pass “&” in the capture list i.e.

 

1

2

3

4

// Capturing all Local variables by Reference

auto func = [&] () {

                   //...

                   };

 

Mixing capturing by value and Reference

We can also mix the capturing mode of Lambda by passing some local variables by value and some by reference i.e.

 

1

2

3

// Capturing All Local variables by value except counter, which is

// captured by reference here.

auto func = [=, &counter] () mutable {};

 

Be-aware of capturing local variables by Reference in Lambda

If in lambda we are capturing local variables by reference, then we need to make sure that when lambda function is accessed or called, then all the by reference captured local variables are still in scope.

If lambda will try to access or modify a by reference captured local variable, which is not in scope anymore i.e. which has been destroyed due to stack unwinding, then crash can happen.

Checkout this example,

 

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

#include <iostream>

#include <string>

#include <functional>

 

std::function<void ()> getCallBack()

{

// Local Variable

int counter = 10;

 

// Defining Lambda function and

// Capturing Local variables by Reference

auto func = [&counter]  () mutable {

std::cout<<"Inside Lambda :: counter = "<<counter<<std::endl;

 

// Change the counter

// Change will affect the outer variable because counter variable is

// captured by Reference in Lambda function

counter = 20;

 

std::cout<<"Inside Lambda :: After changing :: counter = "<<counter<<std::endl;

 

};

 

return func;

}

 

int main(int argc, char **argv)

{

 

std::function<void ()> func = getCallBack();

 

//Call the Lambda function

func();

 

// Lambda function will access and modify the variable that has been captured it by reference

// But that variable was actually a local variable on stack which was removed from stack when getCallbacK() returned

// So, lambda function will basically corrupt the stack

 

return 0;

}

Output

 

1

2

3

Inside Lambda :: counter = 0

Inside Lambda :: After changing :: counter = 20

Segmentation fault (core dumped)

Here we tried to accessed the variable that has already been destructed due to stack unwinding.

To compile the above examples in linux use following command,

g++ –std=c++11 example.cpp

zzhongcy
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【BOOST C++ 12 函数式编程】（3） Boost.Boost.Bind
gongdiwudu的专栏
11-14 3697
Boost.Bind 是一个库，它简化和概括了最初需要 std::bind1st() 和 std::bind2nd() 的功能。这两个函数被添加到 C++ 98 的标准库中，即使它们的签名不兼容，也可以连接函数。
boost::bind的使用
热门推荐
无心云
03-25 3万+
<br />最近在几经波折之后，终于对于boost::bind有点理解了。对于习惯了其他语言的人来说，boost::bind是个挺神奇的东西，它可以将你的方法适配成任何其他的方法。其实这得益于c++的模板以及操作符重载，去看boost::bind的实现就会发现它是一个有n多重载的函数，这些重载主要是为了适应函数的参数个数。<br /> <br />其实boost::bind的原理是函数对象，而函数对象就是一个重载了()操作符的对象，这样我们就可以像调用一个方法一样来调用一个类上的这个操作符，比如a()，其实
Boost.Bind用法详解（一）
郁闷阳光的专栏
05-15 1093
Boost.Bind 为函数和函数对象提供了一致的语法，对于值语义和指针语义也一样。我们将从一些简单的例子开始，处理一些简单绑定的用法，然后再转移到通过嵌套绑定进行函数组合。弄明白如何使用 bind 的关键是，占位符的概念。占位符用于表示提供给结果函数对象的参数，Boost.Bind 支持最多九个参数。占位符被命名为 _1, _2, _3, _4, 直至 _9, 你要把它们放在你原先放参数
手把手教你实现boost::bind
andun6063的博客
04-16 649
前言 boost::bind操作想必大家都使用过，它特别神奇，能够绑定函数与参数，绑定后能够改变参数数量，并且还可以使用占位符。它可以绑定普通函数也可以绑定类成员函数。好多小伙伴试图看过boost::bind的源码，但是可能效果不佳。原因在于boost::bind的代码考虑了很多使用情况，而且还要兼容各种编译环境，所以实现的代码很复杂，很容易在看源码的时候被各种宏定义带跑偏，以至于乱了思...
boost::bind 不能处理函数重载 (error: no matching function for call to ‘bind‘)
m0_56069948的博客
05-30 1075
🚀 优质资源分享 🚀 学习路线指引（点击解锁） 知识定位 人群定位 🧡 Python实战微信订餐小程序 🧡 进阶级 本课程是python flask+微信小程序的完美结合，从项目搭建到腾讯云部署上线，打造一个全栈订餐系统。 💛Python量化交易实战💛 入门级 手把手带你打造一个易扩展、更安全、效率更高的量化交易系统 前言 最近任务多、工期紧，没有时间更新博客，就水一期吧。虽然是水，也不能太失水准，刚好最近工作中遇到一个 boost::bind 的问题，花费了半天时间来定位解决，就说
C++ boost::asio编程-异步TCP详解及实例代码
09-01
为了更好地管理回调和数据，可以使用仿函数、`boost::bind`或lambda表达式来绑定额外的参数。此外，`io_service`通常在一个单独的线程中运行，以便在处理其他任务的同时处理I/O事件。 总结来说，Boost.Asio的异步...
boost::function用法详解
amoscykl的博客
10-25 2056
今天学习muduo网络库源码的时候看到了boost::function，写篇笔记记录下。   书上是这样描述的：function是一个函数对象的“容器”，概念上像是C/C++中函数指针类型的泛华，是一种“智能函数指针”。它以对象的形式封装了原始的函数指针或函数对象，能够容纳任意符合函数签名的可调用对象。因此，它可以被用于回调机制，暂时保管函数或函数对象，在之后需要的时机在调用，使回调机制拥有更...
详细解析boost中bind的实现
duoerbasilu
07-26 244
写在前面的话 在C++11之后，std::bind是C++标准库的一个组件了。一开始想弄个C++11的实现来研究下，发现里面用到了可变参数模板（代码变得非常神奇）. http://llvm.org/svn/llvm-project/libcxx/trunk/include/functional 还是弄个原始点的boost的实现来研究下。 话说网上关于boost::bind的实现的文章也...
Boost::bind
liuxyen的博客
12-14 640
Boost::bind 一 Boost::bind         在STL中，我们经常需要使用bind1st，bind2st函数绑定器和fun_ptr,mem_fun等函数适配器，这些函数绑定器和函数适配器使用起来比较麻 烦，需要根据是全局函数还是类的成员函数，是一个参数还是多个参数等做出不同的选择，而且有些情况使用STL提供的不能满足要求，所以如 果可以我们最好使用b
boost::bind()详解
amoscykl的博客
10-25 709
使用 boost::bind是标准库函数std::bind1st和std::bind2nd的一种泛化形式。其可以支持函数对象、函数、函数指针、成员函数指针，并且绑定任意参数到某个指定值上或者将输入参数传入任意位置。   1. 通过functions和function pointers使用bind 给定如下函数： int f(int a, int b) { return a + ...
Boost::bind使用详解
最新发布
zxnzjccmily的博客
02-10 1674
boost::bind
boost::bind
weixin_40603219的博客
03-16 563
https://www.cnblogs.com/blueoverflow/p/4740093.html //注册action服务 //注册action的回调函数execute //把_1和server作为两个参数，每次调用回调函数都把这两个参数传进去 //_1是占用符，详见https://www.cnblogs.com/blueoverflow/p/4740093.html actionlib...
boost::bind简要介绍
sj19890401
10-19 527
boost::bind是一个很神奇的东西。他可以把函数（包括类成员函数!)和其参数一起打包成一个函数对象。未引入它之前，基于面向对象架构的软件往往很难在接口设计中引入回调函数的——因为类成员函数无法直接作为回调函数使用——当然，有办法可以搞定，比如把this指针作为回调函数的参数传入。但是这些解决之道往往比较扭曲，远不如bind来得简单直接。虽然bind也是有代价的，调用的时间代价(包括bind的
C++ boost::bind
reason的博客
02-04 199
C++ boost::bind的理解https://blog.csdn.net/xiaolubk/article/details/79043463?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-5.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnP..
boost::bind 绑定
ahelloyou的博客
05-29 708
bind是一种非常神奇的存在，它不是一个单独的类或者函数，依据绑定的参数的个数和要绑定的调用对象的类型，总共有数十种不同的形式，编译器会根据具体的绑定代码制动确定要使用的正确的形式。 话不多说，直接上例子说用法。 1.bind绑定普通函数（函数指针） 定义函数 int f(int a,int b) { return a + b; } int g(int a,int b,int c) { return a + b + c; } typedef int (*f_pointer)(int,
boost::bind()
weixin_38009585的博客
10-30 253
其实boost::bind的原理是函数对象，而函数对象就是一个重载了()操作符的对象，这样我们就可以像调用一个方法一样来调用一个类上的这个操作符，比如a()，其实你是在调用a这个对象的()方法，而不是调用一个叫a的方法。一般来说boost::bind有两种方式的调用，一种是对自由方法，也取非类方法， 一种是对类方法。对自由方法来说，直接boost::bind(函数名, 参数1，参数2，…) 对类方
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值