c ++保存绑定对象并在asio之后使用它

Question

我试图将绑定结果保存到std：function，然后将其作为参数传递给另一个函数，并将其存储为数据成员。然后我使用asio async_wait，但当我从等待返回，并尝试操作我保存的功能我得到分段错误。任何想法为什么？

#include <memory>
#include <iostream>
#include <asio/io_service.hpp>
#include <functional>
#include <asio/deadline_timer.hpp>

using namespace std;

typedef std::function<void (const std::error_code& error)> TM_callback;

class Timer {
public:
    Timer(asio::io_service& io_service) :_timer(io_service) {}

    void start(TM_callback cb) {
        _cb = cb;
      _timer.expires_from_now(boost::posix_time::milliseconds(1000));
        TM_callback timeoutFunc = std::bind(&Timer::onTimeout, this, std::placeholders::_1);
        _timer.async_wait(timeoutFunc);
    }

private:
    void onTimeout(const std::error_code& error) {
        (_cb)(error); // <-- here i get segmentation fault
    }

    TM_callback _cb;
    asio::deadline_timer _timer;
};

class COL {
public:
    COL(asio::io_service& io_service): _inTimer(io_service){}
void startInTimer() {
    TM_callback cb = std::bind(&COL::onInTimeout, this, std::placeholders::_1);
    _inTimer.start(cb);
}

private:
void onInTimeout(const std::error_code& error) {cout<<error.message();}
    Timer _inTimer;
};

int main()
{
    asio::io_service io_service;
    COL col(io_service);
    col.startInTimer();

    return 0;
}

Answer 1

好的，最可能的问题是你没有展示的代码。如你所见@ m.s。没有“想象”你的问题。他也忘记了io_service::run()：

int main() {
    asio::io_service io_service;
    COL col(io_service);
    col.startInTimer();
    io_service.run();
}

仍然没问题。的 Live On Coliru

在执行完成处理程序之前，inTimer无法保证生效时，问题就开始了：

int main() {
    asio::io_service io_service;
    {
        COL col(io_service);
        col.startInTimer();
    }
    io_service.run();
}

现在你有Undefined Behaviour： Live On Coliru

解决方案

最简单的解决方案是让COL（ 那个？）对象的生存时间足够长。让bind保持Timer对象存活的结构/惯用方式越多，例如使用shared_ptr：

<强> Live On Coliru

#include <iostream>
#include <boost/bind.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/make_shared.hpp>
#include <boost/asio.hpp>

using namespace std;

typedef std::function<void(const boost::system::error_code &error)> TM_callback;

namespace asio = boost::asio;

class Timer : public boost::enable_shared_from_this<Timer> {
  public:
    Timer(asio::io_service &io_service) : _timer(io_service) {}

    void start(TM_callback cb) {
        _cb = cb;
        _timer.expires_from_now(boost::posix_time::milliseconds(1000));
        TM_callback timeoutFunc = boost::bind(&Timer::onTimeout, shared_from_this(), boost::asio::placeholders::error);
        _timer.async_wait(timeoutFunc);
    }

  private:
    void onTimeout(const boost::system::error_code &error) {
        (_cb)(error);
    }

    TM_callback _cb;
    asio::deadline_timer _timer;
};

class COL : public boost::enable_shared_from_this<COL> {
  public:
    COL(asio::io_service &io_service) : _svc(io_service) {}

    void startInTimer() {
        TM_callback cb = boost::bind(&COL::onInTimeout, shared_from_this(), boost::asio::placeholders::error);

        boost::shared_ptr<Timer> _inTimer = boost::make_shared<Timer>(_svc);
        _inTimer->start(cb);
    }

  private:
    void onInTimeout(const boost::system::error_code &error) { cout << error.message(); }
    asio::io_service& _svc;
};

int main() {
    asio::io_service io_service;
    {
        boost::make_shared<COL>(io_service)->startInTimer();
    }
    io_service.run();
}

请注意，这巧妙地解决了多个计时器在给定时间无法飞行的问题（安排新的计时器会取消待处理的计时器）。