我正在尝试写一个包装器std::thread:

#include <thread>
#include <iostream>

struct A {};

template <typename F, typename... Args>
void lifted_lambda_1(void *m, F &&entrypoint,  Args&&... args) {
    std::cout << "I will do something with the void * " << m << std::endl;
    entrypoint(std::forward<Args>(args)...);
}


template <typename F, typename... Args>
void make_thread(void *p, F &&f, Args && ... args) {
    std::thread(lifted_lambda_1<typename std::decay<F>::type, Args...>, p, std::forward<F>(f), std::forward<Args>(args)...).detach();
}

int main() {
    A a;
    make_thread(nullptr, [](A x){}, a);
}

但是当我编译它时，我得到一个错误：

In file included from /usr/local/sqream-prerequisites/package-install/gcc-4.8.2/include/c++/4.8.2/thread:39:0,
                 from bubu.cpp:1:
/usr/local/sqream-prerequisites/package-install/gcc-4.8.2/include/c++/4.8.2/functional: In instantiation of ‘struct std::_Bind_simple<void (*(void*, main()::__lambda0, A))(void*, main()::__lambda0&&, A&)>’:
/usr/local/sqream-prerequisites/package-install/gcc-4.8.2/include/c++/4.8.2/thread:137:47:   required from ‘std::thread::thread(_Callable&&, _Args&& ...) [with _Callable = void (&)(void*, main()::__lambda0&&, A&); _Args = {void*&, main()::__lambda0, A&}]’
bubu.cpp:15:132:   required from ‘void make_thread(void*, F&&, Args&& ...) [with F = main()::__lambda0; Args = {A&}]’
bubu.cpp:20:38:   required from here
/usr/local/sqream-prerequisites/package-install/gcc-4.8.2/include/c++/4.8.2/functional:1697:61: error: no type named ‘type’ in ‘class std::result_of<void (*(void*, main()::__lambda0, A))(void*, main()::__lambda0&&, A&)>’
       typedef typename result_of<_Callable(_Args...)>::type result_type;
                                                             ^
/usr/local/sqream-prerequisites/package-install/gcc-4.8.2/include/c++/4.8.2/functional:1727:9: error: no type named ‘type’ in ‘class std::result_of<void (*(void*, main()::__lambda0, A))(void*, main()::__lambda0&&, A&)>’
         _M_invoke(_Index_tuple<_Indices...>)

出现这个错误的原因是什么？我如何解决它？

std::thread总是会衰减它的参数（由于上面评论之一的链接给出的原因）。您可以使用reference_wrapper保护引用，以便参数可以通过左值引用传递。

要使其同时适用于左值和右值参数，您需要一个包装函数，它将左值包装在reference_wrapper但允许右值被复制（或移动）并作为右值转发。这会not是“完美”转发，因为右值将被复制，而不是作为右值引用转发，因此使用新对象调用目标函数。

因此，您可以使用类似的方法有条件地包装左值，但仅转发右值：

template<typename T>
std::reference_wrapper<std::remove_reference_t<T>>
wrap(T& t) { return std::ref(t); }

template<typename T>
T&&
wrap(typename std::remove_reference<T>::type&& t)
{ return std::move(t); }

(remove_reference用于第二次过载，以便T处于非推导上下文中，因此该参数不是转发引用）。

然后将其用作线程构造函数的参数：

std::thread(lifted_lambda_1<typename std::decay<F>::type, Args...>, p,
            std::forward<F>(f), wrap<Args>(args)...).detach();
                                /*^^^^^^^^^^^^*/

然而，这样做会带来所有问题std::thread试图通过复制其参数来避免！您必须确保任何左值传递给make_thread在线程完成运行之前不会超出范围。由于您要分离线程，因此通常很难做到这一点。使用此功能时必须非常小心。

您可能可以编写自己的类模板，其行为类似于reference_wrapper保护右值引用，以避免创建新对象，但是您还必须小心，线程函数的右值参数在线程完成运行之前不会超出范围（如果它们是右值，则很可能他们是临时工，将not比创建新线程的调用更长寿！）

这里有龙。