如何用函数对象实现生产者线程调用结构体成员函数、传参并优化返回类型？

针对你提出的三个问题，直接给出可行的实现方案：

1. 改用函数对象实现 #

你可以用std::function包装绑定了实例的成员函数，将其作为队列的元素类型。结合lambda表达式或者std::bind，就能把结构体A的成员函数转换成可直接调用的函数对象。

示例代码：

#include <functional>
#include <queue>
#include <variant>
#include <iostream>

struct A {
    int func_1(int a) { return a * 2; }
    double func_2(double b) { return b + 1.5; }
};

// 任务队列元素类型：无参可调用对象，返回std::variant<int, double>
using Task = std::function<std::variant<int, double>()>;
std::queue<Task> queue_in;

// 生产者：将成员函数包装成任务入队
void producer(A& obj) {
    // 用lambda绑定实例和函数，包装为无参任务
    queue_in.emplace([&obj]() { return std::variant<int, double>(obj.func_1(10)); });
    queue_in.emplace([&obj]() { return std::variant<int, double>(obj.func_2(3.0)); });
}

2. 传递成员函数的参数 #

核心思路是把成员函数、实例、参数三者打包成一个无参的可调用对象，队列只需要存储这个对象即可。常用两种方式实现：

• 用lambda捕获参数：上面的示例已经用到，直接在lambda里传入参数并调用成员函数。
• 用std::bind绑定参数：

#include <functional>

// 生产者用std::bind包装任务
void producer_bind(A& obj) {
    auto task1 = std::bind(&A::func_1, &obj, 20);
    queue_in.emplace([task1]() { return std::variant<int, double>(task1()); });
    
    auto task2 = std::bind(&A::func_2, &obj, 5.5);
    queue_in.emplace([task2]() { return std::variant<int, double>(task2()); });
}

消费者只需要调用队列中的任务，无需额外处理参数。

3. 避免使用std::variant作为返回类型 #

完全可以，最实用的方案是用回调函数替代结果队列：把处理结果的逻辑和任务打包在一起，任务执行完成后直接调用回调处理结果，不需要将结果存入queue_out。

示例代码：

// 定义任务类型：无参无返回，内置结果处理回调
using TaskWithCallback = std::function<void()>;
std::queue<TaskWithCallback> queue_in;

// 生产者：绑定任务与结果处理逻辑
void producer_with_callback(A& obj) {
    // 处理func_1结果的回调
    auto callback1 = [](int result) { std::cout << "func_1 result: " << result << std::endl; };
    queue_in.emplace([&obj, callback1]() { callback1(obj.func_1(10)); });
    
    // 处理func_2结果的回调
    auto callback2 = [](double result) { std::cout << "func_2 result: " << result << std::endl; };
    queue_in.emplace([&obj, callback2]() { callback2(obj.func_2(3.0)); });
}

// 消费者：直接执行任务，结果自动通过回调处理
void consumer() {
    while (!queue_in.empty()) {
        auto task = queue_in.front();
        queue_in.pop();
        task();
    }
}

这种方式不需要统一返回类型，每个任务自带适配自身结果的处理逻辑。如果一定要保留结果队列，也可以用std::any存储结果，但后续处理仍需判断类型，灵活性不如回调方案。

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