使用boost::asio线程池post时出现boost::get_pointer错误求助

错误根源 #

你遇到的boost::get_pointer相关错误，核心是绑定类成员函数时未指定对象实例。asyncFunc是类A的非静态成员函数，调用它必须依赖类的实例（即this指针）。你写的boost::bind(&A::asyncFunc, 3)仅传入了参数3，未指定调用哪个A对象的asyncFunc，Boost无法解析对应的实例，因此触发错误。

此外，当前代码还存在逻辑问题：主线程在post异步任务后会立刻执行afterFunc()，不会等待4个asyncFunc完成，完全不符合你要求的依赖关系。

修正后的实现方案 #

以下代码既修复了绑定错误，也保证了beforeFunc()→并行执行4个asyncFunc→afterFunc()的顺序依赖：

#include <boost/asio/post.hpp>
#include <boost/asio/thread_pool.hpp>
#include <boost/asio/experimental/wait_group.hpp>
#include <iostream>
#include <chrono>
#include <thread>

class A {
public:
    void asyncFunc(int i)
    {
        std::this_thread::sleep_for(std::chrono::seconds(3));
        std::cout << i << " ";
    }

    void beforeFunc()
    {
        std::cout << "Before\n";
    }

    void afterFunc()
    {
        std::cout << "\nAfter\n";
    }

    void otherFunc()
    {
        boost::asio::thread_pool pool(4);
        for(int i = 0; i < 10; i++) // 示例改为10次循环，可改回1000次
        {
            beforeFunc();
            
            // 用Boost Asio的wait_group跟踪异步任务完成状态
            boost::asio::experimental::wait_group task_wg;
            
            // 封装任务提交逻辑，避免重复代码
            auto submit_task = [this, &pool, &task_wg](int num) {
                task_wg.add(1);
                boost::asio::post(pool, [this, num, &task_wg]() {
                    this->asyncFunc(num);
                    task_wg.done();
                });
            };

            // 提交4个并行任务
            submit_task(3);
            submit_task(0);
            submit_task(2);
            submit_task(1);
            
            // 等待所有异步任务执行完毕
            task_wg.wait();
            
            afterFunc();
        }
        pool.join();
    }
};

int main()
{
    A a;
    a.otherFunc();
}

关键修正点 #

1. 绑定成员函数时传入实例：通过lambda捕获this指针，确保asyncFunc能找到所属的A对象实例，替代了容易出错的boost::bind写法。
2. 用wait_group跟踪任务完成：boost::asio::experimental::wait_group是Boost提供的轻量级工具，专门用于等待一组异步任务全部完成，完美满足你的依赖需求。
3. 代码简化：封装submit_task函数避免重复代码，同时优化输出格式，让执行顺序更直观。

另一种可选方案（用std::future） #

如果你更习惯标准库工具，也可以用std::packaged_task配合std::future实现等待：

// 在otherFunc的循环内替换相关逻辑：
beforeFunc();
std::vector<std::future<void>> task_futures;
task_futures.reserve(4);

auto wrap_task = [this](int num) {
    return std::packaged_task<void()>([this, num]() { this->asyncFunc(num); });
};

auto task1 = wrap_task(3);
task_futures.push_back(task1.get_future());
boost::asio::post(pool, std::move(task1));

auto task2 = wrap_task(0);
task_futures.push_back(task2.get_future());
boost::asio::post(pool, std::move(task2));

auto task3 = wrap_task(2);
task_futures.push_back(task3.get_future());
boost::asio::post(pool, std::move(task3));

auto task4 = wrap_task(1);
task_futures.push_back(task4.get_future());
boost::asio::post(pool, std::move(task4));

// 等待所有任务完成
for(auto& fut : task_futures) {
    fut.wait();
}

afterFunc();

内容的提问来源于stack exchange，提问作者Zefelix