C++11传递两个可变参数编译错误及函数指针任务队列问题

Hey there! Let's work through this issue together. Since you mentioned your template method for enqueuing function pointers (with parameters and a callback) isn't compiling with Clang, I’ll start by covering common pitfalls and share a working example you can adapt. If this doesn’t hit your exact problem, feel free to drop your code snippet and the full Clang error messages—those will help zero in on the issue.

Common Causes of Compilation Failures with This Setup #

• Mismatched Function Pointer Types: It’s easy to mix up the order of parameters vs. the callback in your function pointer signature, or use incompatible callback types (e.g., raw function pointer vs. std::function).
• Template Argument Deduction Issues: Clang can be strict about deducing parameter packs and callback types, especially if your template method doesn’t explicitly disambiguate them.
• Incorrect Task Storage: If your task class doesn’t properly handle parameter forwarding or callback ownership, Clang will throw errors about incomplete types or invalid conversions.

Working Example Implementation #

Here’s a complete, compilable setup that handles function pointers with parameters and a callback, tested with Clang:

Step 1: Task Structure to Store Function, Parameters, and Callback #

#include <functional>
#include <queue>
#include <tuple>
#include <utility>

// Generic task wrapper for function pointers with args + callback
template<typename Ret, typename... Args, typename Callback>
struct Task {
    using FuncType = Ret(*)(Args..., Callback);

    FuncType func;
    std::tuple<Args...> args;
    Callback callback;

    // Forward arguments to avoid copies where possible
    Task(FuncType f, Args&&... task_args, Callback&& cb)
        : func(f),
          args(std::forward<Args>(task_args)...),
          callback(std::forward<Callback>(cb)) {}

    // Execute the task by unpacking parameters and calling the function
    void run() {
        std::apply([this](auto&&... unpacked_args) {
            this->func(std::forward<decltype(unpacked_args)>(unpacked_args)..., this->callback);
        }, this->args);
    }
};

Step 2: Task Queue with Template Enqueue Method #

class TaskQueue {
private:
    // Use std::function to erase task type for uniform storage
    std::queue<std::function<void()>> task_queue_;

public:
    // Template method to accept function pointer, parameters, and callback
    template<typename Ret, typename... Args, typename Callback>
    void enqueue(Ret(*func)(Args..., Callback), Args&&... args, Callback&& cb) {
        // Wrap the Task in a lambda that can be stored as std::function
        task_queue_.emplace([task = Task<Ret, Args..., Callback>(
            func, std::forward<Args>(args)..., std::forward<Callback>(cb))]() mutable {
            task.run();
        });
    }

    // Process all tasks in the queue
    void process_all() {
        while (!task_queue_.empty()) {
            auto current_task = std::move(task_queue_.front());
            task_queue_.pop();
            current_task();
        }
    }
};

Step 3: Usage Example #

#include <cstdio>

// Example function matching the expected signature: args first, callback last
int multiply(int x, int y, std::function<void(int)> result_callback) {
    int product = x * y;
    result_callback(product);
    return product;
}

int main() {
    TaskQueue queue;

    // Enqueue a task with parameters and a lambda callback
    queue.enqueue(multiply, 4, 6, [](int res) {
        printf("Multiplication result: %d\n", res);
    });

    queue.process_all();
    return 0;
}

Fixing Common Clang Errors #

If you’re seeing specific errors, here’s how to address them:

• no matching member function for call to 'enqueue': Double-check that your function pointer’s signature matches the order of arguments you’re passing (parameters first, callback last). Also ensure the callback type (e.g., raw pointer vs. std::function) aligns with what the function expects.
• invalid use of incomplete type: Make sure all template parameters are properly deduced. If your callback is a complex type, you might need to explicitly specify template arguments for enqueue.
• cannot convert lambda to std::function<void()>: Ensure your lambda doesn’t capture non-copyable objects, and that the run() method of your Task struct is accessible and correctly implemented.

If you’re still stuck, share your code and the exact Clang error output—we’ll get it sorted!

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