如何在C++11中实现带可变参数的多态任务执行接口？

问题背景 #

需要创建TaskExecutorInterface接口类实现多态，ConcreteTaskExecutor在编译期已知参数类型，将接口指针传入其他类后调用带任意参数的虚函数executeTask，但两种尝试写法均报错：

• 第一种使用模板虚函数，触发错误member function templates cannot be virtual：C++不允许虚函数为模板，因为虚函数表（vtable）需在编译期确定条目，而模板函数需按需实例化，无法提前生成所有可能的vtable项。
• 第二种用无参虚函数，派生类重载带参版本，触发参数数量不匹配错误：多态调用仅识别基类声明的函数签名，基类无带参executeTask，因此通过接口指针无法调用派生类的重载函数。

可行实现方案（C++11兼容） #

方案1：固定参数类型的Tuple打包方案 #

核心思路是将参数打包为固定类型的std::tuple，让接口的虚函数签名固定，派生类负责解析tuple并执行逻辑。

#include <iostream>
#include <tuple>
#include <utility>

// 任务执行接口
class TaskExecutorInterface {
public:
    // 虚函数接收固定类型的tuple参数
    virtual void executeTask(std::tuple<int, double, const char*> params) const = 0;

    virtual ~TaskExecutorInterface() = default;
};

// 具体任务执行器
class ConcreteTaskExecutor : public TaskExecutorInterface {
private:
    // 实际执行逻辑
    void doExecute(int arg1, double arg2, const char* arg3) const {
        std::cout << "ConcreteTaskExecutor::executeTask called with parameters: "
                  << arg1 << ", " << arg2 << ", " << arg3 << std::endl;
    }

public:
    // 实现接口虚函数，解析tuple参数
    void executeTask(std::tuple<int, double, const char*> params) const override {
        doExecute(std::get<0>(params), std::get<1>(params), std::get<2>(params));
    }
};

// 使用接口的类
class AnotherClass {
public:
    explicit AnotherClass(const TaskExecutorInterface* executor) : taskExecutorPtr(executor) {}

    // 模板函数打包参数并调用接口
    template <typename... Params>
    void performTask(Params&&... params) const {
        if (taskExecutorPtr) {
            auto params_tuple = std::make_tuple(std::forward<Params>(params)...);
            taskExecutorPtr->executeTask(params_tuple);
        } else {
            std::cout << "TaskExecutorInterface pointer is null." << std::endl;
        }
    }

private:
    const TaskExecutorInterface* taskExecutorPtr;
};

int main() {
    ConcreteTaskExecutor concreteExecutor;
    AnotherClass anotherClass(&concreteExecutor);

    anotherClass.performTask(42, 3.14, "Hello");

    return 0;
}

方案2：通用类型擦除方案（支持任意参数类型） #

通过模板派生类结合自定义index_sequence实现类型擦除，支持不同参数类型的任务执行器。

#include <iostream>
#include <tuple>
#include <utility>
#include <functional>
#include <memory>

// C++11手动实现index_sequence
template<size_t...>
struct index_sequence {};

template<size_t N, size_t... Indices>
struct make_index_sequence_impl : make_index_sequence_impl<N-1, N-1, Indices...> {};

template<size_t... Indices>
struct make_index_sequence_impl<0, Indices...> : index_sequence<Indices...> {};

template<size_t N>
using make_index_sequence = make_index_sequence_impl<N>;

// 任务执行接口
class TaskExecutorInterface {
public:
    virtual void executeTask() const = 0;

    virtual ~TaskExecutorInterface() = default;
};

// 通用任务执行器模板：封装任务函数与参数
template<typename Func, typename... Params>
class GenericTaskExecutor : public TaskExecutorInterface {
private:
    Func m_func;
    std::tuple<Params...> m_params;

    // 展开tuple参数执行任务
    template<size_t... Indices>
    void execute_impl(index_sequence<Indices...>) const {
        m_func(std::get<Indices>(m_params)...);
    }

public:
    GenericTaskExecutor(Func func, Params&&... params)
        : m_func(std::move(func)), m_params(std::forward<Params>(params)...) {}

    void executeTask() const override {
        execute_impl(make_index_sequence<sizeof...(Params)>{});
    }
};

// 辅助函数：创建通用任务执行器实例
template<typename Func, typename... Params>
std::unique_ptr<TaskExecutorInterface> createTaskExecutor(Func func, Params&&... params) {
    return std::unique_ptr<TaskExecutorInterface>(
        new GenericTaskExecutor<Func, Params...>(std::move(func), std::forward<Params>(params)...)
    );
}

// 使用接口的类
class AnotherClass {
public:
    explicit AnotherClass(std::unique_ptr<TaskExecutorInterface> executor) 
        : taskExecutorPtr(std::move(executor)) {}

    void performTask() const {
        if (taskExecutorPtr) {
            taskExecutorPtr->executeTask();
        } else {
            std::cout << "TaskExecutorInterface pointer is null." << std::endl;
        }
    }

private:
    std::unique_ptr<TaskExecutorInterface> taskExecutorPtr;
};

// 具体任务逻辑
void concreteTask(int arg1, double arg2, const char* arg3) {
    std::cout << "Concrete task called with parameters: "
              << arg1 << ", " << arg2 << ", " << arg3 << std::endl;
}

int main() {
    auto executor = createTaskExecutor(concreteTask, 42, 3.14, "Hello");
    AnotherClass anotherClass(std::move(executor));

    anotherClass.performTask();

    return 0;
}

方案说明 #

• 方案1适用于参数类型固定的场景，实现简洁，直接通过tuple传递参数。
• 方案2通过类型擦除支持任意参数类型的任务执行器，灵活性更高，在创建执行器时绑定参数，调用时无需传递参数。

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