Pass tuple's content as variadic function arguments

Question

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...);
            }          
};

Use case:

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.

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));
}

right?

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...

Answer 1

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

Note that you could use std::function with std::bind instead, eg 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();
    }
    // ...

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.