c++11封装thread库的方法示例

template< class Function, class... Args > 
explicit thread( Function&& f, Args&&... args );

error_code create_thread((void_or_error_code(*entry)(void *), void *data);

void_or_error_code entry_point(void *arbitrary_data);

struct thread_data_base
{
 virtual ~thread_data_base(){}
 virtual void run()=0;
};

std::tuple<typename std::decay<F>::type, typename std::decay<ArgTypes>::type...> fp;

void_or_error_code thread_entry(void *data) {
 std::unique_ptr<thread_data_base> p((thread_data_base *)data);
 p->run();
 // return result of p->run() if error code is required
}

template<typename F, class... ArgTypes>
class thread_data : public thread_data_base
{
public:
 thread_data(F&& f_, ArgTypes&&... args_): fp(std::forward<F>(f_), std::forward<ArgTypes>(args_)...) {}
private:
 std::tuple<typename std::decay<F>::type, typename std::decay<ArgTypes>::type...> fp;
}

template<typename F, class... ArgTypes>
inline thread_data_base *make_thread_data(F&& f, ArgTypes&&... args)
{
 return new thread_data<typename std::remove_reference<F>::type, ArgTypes...>(std::forward<F>(f),
                   std::forward<ArgTypes>(args)...); // 啥时候释放？
}

tp.get<0>()(tp.get<1>(), tp.get<2>(), tp.get<3>());

template <std::size_t Ep, std::size_t Sp>
struct make_tuple_indices {...};

template <std::size_t Sp, class IntTuple, std::size_t Ep> struct make_indices_imp;

template <std::size_t Sp, std::size_t... Indices, std::size_t Ep>
struct make_indices_imp<Sp, tuple_indices<Indices...>, Ep>
{ typedef typename make_indices_imp<Sp+1, tuple_indices<Indices..., Sp>, Ep>::type type; };

template <std::size_t Ep, std::size_t... Indices>
struct make_indices_imp<Ep, tuple_indices<Indices...>, Ep>
{ typedef tuple_indices<Indices...> type; };

template <std::size_t Ep, std::size_t Sp=0>
struct make_tuple_indices {
 typedef typename make_indices_imp<Sp, tuple_indices<>, Ep>::type type;
};