我们先来看一下具体的功能:

void boo1 () { std::cout << "boo1\n"; }
void boo2 (std::string) { std::cout << "boo2\n"; }

struct X {
    void boo3 () { std::cout << "boo3\n"; }
    void boo4 (std::string) { std::cout << "boo4\n"; }
};

我希望这些功能与一些“守卫”功能一起执行，该功能可以进行异常保护(下面的解释)。所以，我写了两个函数，一个是自由函数，另一个是成员函数:

template <typename C, typename... Args>
typename std::enable_if<!std::is_member_function_pointer<C>::value, void>::type
foo (C&& c, Args&&... args) {
    std::cout << "not memfun\n";
    c (std::forward<Args> (args)...);
}

template <typename C, typename T, typename... Args>
typename std::enable_if<std::is_member_function_pointer<C>::value, void>::type
foo (C&& c, T* o, Args&&... args) {
    std::cout << "memfun\n";
    (o->*c) (std::forward<Args> (args)...);
}

现在我要执行 boo1()、boo2()、X::boo3() 和 X: :boo4() 在新线程中，但具有 foo() 函数使用的“保护”。所以，没有任何问题，我可以这样做:

X x;
std::thread th1 {&foo<void (*) ()>, &boo1};
std::thread th2 {&foo<void (*) (std::string), std::string>, &boo2, "Hello"};
std::thread th3 {&foo<void (X::*) (), X>, &X::boo3, &x};
std::thread th4 {&foo<void (X::*) (std::string), X, std::string>, &X::boo4, &x, "Hello"};

因此，更进一步，我编写了线程包装器类以停止显式使用 std::join() 或 std::detach()。 Insted 其中之一在析构函数运行时被调用。为了本示例的简单性，我只使用了其中一个。 因此，代码如下所示:

class Th {
public:
    template <typename C, 
              typename = typename std::enable_if<!std::is_member_function_pointer<C>::value, void>::type,
              typename... Args>
    Th (C&& c, Args... args) // (X)
    : t {foo<C, Args...>, std::forward<C> (c), std::forward<Args> (args)...} {}

    template <typename C,
              typename = typename std::enable_if<std::is_member_function_pointer<C>::value, void>::type,
              typename T,
              typename... Args>
    Th (C&& c, T* o, Args... args) // (Y)
    : t { foo<C, T, Args...>, std::forward<C> (c), o, std::forward<Args> (args)...} {}


    ~Th () { t.join (); }

private:
    std::thread t;
};

而且用这个实现是没有问题的，下面的使用案例:

X x;
Th h1 {&boo1};
Th h2 {&boo2, "Hello"};
Th h3 {&X::boo3, &x};
Th h4 {&X::boo4, &x, "Hello"};

按异常(exception)情况工作。然而这里有一个缺陷——没有完美的转发。如果我将 (X) 和 (Y) Args... 更改为 Args&&... 这是想要的， 代码未编译时出现一些错误，其中之一是:

error: no type named ‘type’ in ‘class std::result_of<void (*(void (*)(std::basic_string<char>), const char*))(void (*&&)(std::basic_string<char>), const char (&)[6])>’

如果我理解正确，std::thread 构造函数中的 std::bind() 无法完成它的工作，如果我错了请纠正我。

我的问题是:在这种情况下，我该怎么做才能利用完美转发？

用于编译它的编译器是 GCC 4.8.1。

promise 的解释:我希望 foo() 函数用 try 包围对 c() 的调用，并且catch 以确保捕获到异常，以某种日志记录机制处理此信息，并在需要时重新抛出异常，并且对 Th 类的用户透明。

最佳答案

将左值引用传递给 std::thread 时，您需要将它们包装在 std::reference_wrapper 中。例如，您可以通过以下方式进行:

namespace detail
{

template<typename T>
std::reference_wrapper<T> forward_to_thread(T& t, std::true_type) {
    return std::ref(t);
}

template<typename T>
T&& forward_to_thread(T&& t, std::false_type) {
    return std::move(t);
}

}

template<typename T>
auto forward_to_thread(T&& t)
    -> decltype(detail::forward_to_thread(std::forward<T>(t), std::is_lvalue_reference<T>{}))
{
    return detail::forward_to_thread(std::forward<T>(t), std::is_lvalue_reference<T>{});
}

然后你只需在 thread 初始化中替换 std::forward 对 forward_to_thread 的调用:

class Th {
public:
    template <typename C,
              typename = typename std::enable_if<!std::is_member_function_pointer<C>::value, void>::type,
              typename... Args>
    Th (C&& c, Args&&... args) // (X)
    : t {foo<C, Args...>, std::forward<C> (c), forward_to_thread<Args> (std::forward<Args>(args))...} {}

    template <typename C,
              typename = typename std::enable_if<std::is_member_function_pointer<C>::value, void>::type,
              typename T,
              typename... Args>
    Th (C&& c, T* o, Args&&... args) // (Y)
    : t { foo<C, T, Args...>, std::forward<C> (c), o, forward_to_thread<Args> (std::forward<Args>(args))...} {}


    ~Th () { t.join (); }

private:
    std::thread t;
};

这确实适用于 gcc 4.8.2 [ link ]

如果您可以使用更新的编译器，请考虑使用 std::invoke (C++17) 以获得更简洁和可读的代码(即 this )。

关于c++ - 将转发引用传递给线程包装器类，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47349533/