《C++Boost库asio》第三篇 怎么绑定成员函数(之前绑定的是自由函数)：

dnfpk001

怎么绑定成员函数(之前绑定的是自由函数)：
1.bind方式（不推荐） 2. lambda（推荐）
async_wait(boost::bind(&printer::print, this));
bind参数：1。成员函数的地址形式 2。调用者

class printer {
public:
  printer(boost::asio::io_service &io) : timer_(io, boost::posix_time::seconds(1)),

count_(0) {
   timer_.async_wait(boost::bind(&printer::print, this));
  }
  ~printer() { std::cout << "Final count is " << count_ << std::endl; }

  void print() {
    // ....do something ....
  }

private:
  boost::asio::deadline_timer timer_;
  int count_;
};

int main() {
boost::asio::io_service io;
printer p(io);
io.run();
return 0;
}

如果是用STL的bind来绑定
#include <functional>//跟函数相关的都在这里头
把bind 改成 std::bind

如果是用lambda来绑定
不用引入头文件
改成 timer_.async_wait([this](const auto&){this->print();});
const auto&是函数自带的参数，boost::system::error_code，是一个错误码，用auto来替代的这种

方式，要求C++14以上版本才能编译

bind返回的是 function<void(const boost::system::error_code)>
lambda返回的是lambda
区别：
function是真正生成一个类的实体，有默认的回调，默认的赋值，操作等。。而且不能在编译器展

开,sizeof也相对要大
lambda可以在编译器展开，开销很小,效率高

避免：绑定的资源，在回调之前就已经失效了
比如这里的this，[]里的资源，timer_.async_wait([this]{const auto&){this->print();});不能让

它在回调之前失效，比如让资源不失效？或者让正常析构的时候，把回调取消掉？先试试，在析构的

时候，调用timer_.cancel() 取消等待的回调，会出现的问题是：timer_在自身析构的过程中，也会

调用cancel的过程，而且如果回调函数中的参数有我自身，实际上已经没有任何意义了，在析构的时

候调用已经晚了，所以cancel没有用
不太正确但是安全的方式：
进行一次判断
timer_async_wait([this](const auto& error) {
if(error == boost::asio::error::operation_aborted) {
  std::cout << "cancel now\n";//出现问题，这个地方不能调用this等资源
} else {
  this -> print();
}
});

dnfpk001

怎么绑定成员函数(之前绑定的是自由函数)：

1.bind方式（不推荐）

1. #include <iostream>
   
2. #include <boost\asio.hpp>
   
3. #include <boost\bind.hpp>
   
4. #include <boost\date_time\posix_time\posix_time.hpp>
   
5. 
   
6. class printer {
   
7. public:
   
8.         printer(boost::asio::io_service &io) :
   
9.                 timer_(io, boost::posix_time::seconds(1)),
   
10.                 count_(0)
    
11.         {
    
12.                 timer_.async_wait(boost::bind(&printer::print, this));
    
13.         }
    
14. 
    
15.         ~printer() {
    
16.                 std::cout << "Final count is " << count_ << std::endl;
    
17.         }
    
18. 
    
19.         void print() {
    
20.                 // ...d0 something ...
    
21.                 std::cout << "in print ..." << std::endl;
    
22.         }
    
23. 
    
24. private:
    
25.         boost::asio::deadline_timer timer_;
    
26.         int count_;
    
27. };
    
28. 
    
29. int main()
    
30. {
    
31.         // 我们的程序和操作系统底层之间的一个相互传递的枢纽
    
32.         // 会把事件按照一定方式进行处理;
    
33.         boost::asio::io_service io;
    
34. 
    
35.         printer p(io);
    
36. 
    
37.         // 开始运行;
    
38.         io.run();
    
39. 
    
40.         std::cout << "mian finish run \n" << std::endl;// 提示下main函数已经结束了
    
41.         system("pause");// 让VS控制台程序不会一闪而过;
    
42.     return 0;
    
43. }

复制代码

如果是用STL的bind来绑定
#include <functional>//跟函数相关的都在这里头
把bind 改成 std::bind

2. lambda（推荐）

如果是用lambda来绑定
不用引入头文件
改成 timer_.async_wait([this](const auto&){this->print();});
const auto&是函数自带的参数，boost::system::error_code，是一个错误码，用auto来替代的这种方式，要求C++14以上版本才能编译

1. #include <iostream>
   
2. #include <boost\asio.hpp>
   
3. #include <boost\date_time\posix_time\posix_time.hpp>
   
4. 
   
5. class printer {
   
6. public:
   
7.         printer(boost::asio::io_service &io) :
   
8.                 timer_(io, boost::posix_time::seconds(1)),
   
9.                 count_(0)
   
10.         {
    
11.                 timer_.async_wait([this](const boost::system::error_code&) {this->print();});
    
12.         }
    
13. 
    
14.         ~printer() {
    
15.                 std::cout << "Final count is " << count_ << std::endl;
    
16.         }
    
17. 
    
18.         void print() {
    
19.                 // ...d0 something ...
    
20.                 std::cout << "in print ..." << std::endl;
    
21.         }
    
22. 
    
23. private:
    
24.         boost::asio::deadline_timer timer_;
    
25.         int count_;
    
26. };
    
27. 
    
28. int main()
    
29. {
    
30.         // 我们的程序和操作系统底层之间的一个相互传递的枢纽
    
31.         // 会把事件按照一定方式进行处理;
    
32.         boost::asio::io_service io;
    
33. 
    
34.         printer p(io);
    
35. 
    
36.         // 开始运行;
    
37.         io.run();
    
38. 
    
39.         std::cout << "mian finish run \n" << std::endl;// 提示下main函数已经结束了
    
40.         system("pause");// 让VS控制台程序不会一闪而过;
    
41.     return 0;
    
42. }
    

复制代码

bind返回的是 function<void(const boost::system::error_code)>
lambda返回的是lambda
区别：
function是真正生成一个类的实体，有默认的回调，默认的赋值，操作等。。而且不能在编译器展开,sizeof也相对要大
lambda可以在编译器展开，开销很小,效率高


避免：绑定的资源，在回调之前就已经失效了
比如这里的this，[]里的资源，timer_.async_wait([this]{const auto&){this->print();});不能让

它在回调之前失效，比如让资源不失效？或者让正常析构的时候，把回调取消掉？先试试，在析构的

时候，调用timer_.cancel() 取消等待的回调，会出现的问题是：timer_在自身析构的过程中，也会

调用cancel的过程，而且如果回调函数中的参数有我自身，实际上已经没有任何意义了，在析构的时候调用已经晚了，所以cancel没有用
不太正确但是安全的方式：
进行一次判断

1. timer_async_wait([this](const auto& error) {
   
2. if(error == boost::asio::error::operation_aborted) {
   
3.   std::cout << "cancel now\n";//出现问题，这个地方不能调用this等资源
   
4. } else {
   
5.   this -> print();
   
6. }
   
7. });

复制代码