将元组的内容作为可变参数传递 [英] Pass tuple's content as variadic function arguments

问题描述

我用 C++0x 玩了一段时间，现在我想使用可变参数模板和元组来实现类任务".我将把 Task 对象传递给新创建的线程(使用 pthread).任务类将包含指向函数的函数指针，该函数应在线程内调用和该函数的参数，简化代码:

I play with C++0x for some time and now I want to use variadic templates and tuple to implement class "Task". I'm going to pass Task objects into newly created threads (using pthread). Task class will contain function pointer to function which should be called inside thread and arguments for this function, simplified code:

class TaskCaller
{
    // ...
    virtual bool dispatch (void);
};

template<typename ...T_arguments> Task :
    public TaskCaller
{
    public:
        // ...
        Task (bool           (*function) (T_arguments&...),
              T_arguments... arguments) :
                  function_arguments_tuple (arguments...),
                  function (function)
        {
            // ...
        }

        bool dispatch (void)
        {
            return TupleUnpack<sizeof ...(T_arguments)>::unpack (this->function, this->function_arguments_tuple);
        }

    private:
        std::tuple<T_arguments&...> function_arguments_tuple;
        bool                        (*function) (T_arguments...);
};

以及我用来将元组解包为函数参数的代码:

And code which I use to unpack tuple into function arguments:

template<unsigned int i>  class TupleUnpack 
{
    public:
        template<typename T_return_type, typename ...T_tuple_arguments, typename ...T_function_arguments>
            inline static T_return_type unpack (T_return_type                     (*function) (T_tuple_arguments&...), 
                                                std::tuple<T_tuple_arguments...>& arguments_tuple,
                                                T_function_arguments              ...function_arguments)
            {
                return TupleUnpack<i-1>::unpack (function, arguments_tuple, std::get<i-1> (arguments_tuple), function_arguments...);
            }                       
};

template<> class TupleUnpack<0> 
{
    public:
        template<typename T_return_type, typename ...T_tuple_arguments, typename ...T_function_arguments>
            inline static T_return_type unpack (T_return_type                     (*function) (T_tuple_arguments&...), 
                                                std::tuple<T_tuple_arguments...>& arguments_tuple,
                                                T_function_arguments              ...function_arguments)
            {
                return function (function_arguments...);
            }          
};

用例:

bool task_function (Foo &foo, Bar &bar)
{
    // ...
    return true;
}

void* thread_function (void* argument)
{
    Task* task ((Task*) argument);

    task->dispatch ();

    delete task;

    pthread_exit (0);
}

void function (void)
{
    Foo             foo (1, 2, 3);
    Bar             bar (1, 2, 3);
    Task<Foo, Bar>* task = new Task (task_function, std::move (foo) std::move (bar));
    pthread_t       thread_id;

    pthread_create (&thread_id, task_function, task);
}

我还没有测试过这段代码，但它只是一个想法.

I have not tested this code yet it's only and idea.

现在我想知道 TupleUnpack 类将如何影响最终代码.据我所知，Task::dispatch 函数的最终实现(在编译器解析模板之后)将相当于:

Now I'm wondering how TupleUnpack class will impact the final code. According to my knowledge final implementation of Task::dispatch function (after compiler parse templates) will be equivalent of:

template<typename ...T_arguments> static bool Task<...T_arguments>::dispatch (void)
{
    return this->function (std::get<0> (this->function_arguments_tuple), std::get<1> (this->function_arguments_tuple), ..., std::get<n> (this->function_arguments_tuple));
}

对吗?

此外，元组本身和 std::get() 应该在最终代码中消失"并且不提供运行时开销 (根据 Boost 文档).

Moreover tuple itself and std::get() should "disappear" in final code and provide no run-time overhead (according to Boost documentation).

也许有更好的方法来解决我的问题...

Maybe there's better way to solve my problem...

推荐答案

它应该是等价的，但唯一可以确定的方法是使用您正在使用的编译器进行测试.

It should be equivalent, but the only way to be sure is to test with the compiler you are using.

请注意，您可以将 std::function 与 std::bind 一起使用，例如类似:

Note that you could use std::function with std::bind instead, e.g. something like:

template<typename ...T_arguments> class Task : public TaskCaller
{
    std::function<bool (T_arguments&...)> functor;
public:
    Task (bool (*func)(T_arguments&...), T_arguments... arguments)
      : functor(std::bind(func, arguments...))
    {}
    bool dispatch() {
        return functor();
    }
    // ...

或者更好的是，让用户传递一个 std::function in:

Or better yet, let the user pass a std::function in:

class Task : public TaskCaller {
    std::function<bool ()> functor;
public:
    Task(std::function<bool ()> func) : functor(func) {}
    // ...

这允许用户选择传递什么而不是强迫他使用自由函数或静态成员函数.

That allows the user to choose what to pass instead of forcing him to use free functions or static member functions.

这篇关于将元组的内容作为可变参数传递的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！