C++11:无法将参数从 'T *const' 转换为 'T *&&'

Question

我有一个可变参数模板类，代表一个带有函数和输入参数的线程。

template<typename F> class my_thread;

template<typename Return, typename... Input>
class my_thread<Return(Input...)>
{
    template<typename F>
    my_thread(F&& f, Input&&... value) : /* mainly std::forward<Input>... to std::tuple<Input...> */ { }
}

现在，实例化该类对于全局函数来说很简单

int fnc(int, double);
my_thread<int(int, double)> thr(fnc, 42, 3.14);

对于某些类的函数成员来说(显然)没那么简单。

my_thread<int(int, double)> thr(&Foo::fnc, 42, 3.14); // won't work, unless Foo::fnc is static.

我知道，std::thread , 有一些机制(可能是部分特化)，如果在所有参数之前传递指向该类实例的指针( std::thread(&Foo::bar, Foo(), 42, 3.14); // OK )，则允许传递非静态成员函数。我无法找到如何做到这一点，所以我的 my_thread需要传递静态成员函数，并且指向该类实例的指针必须是该函数的显式参数。

struct Dog
{
    void bark();
    static void bark(Dog* dog)
    {
        dog->bark();
    }
}

这是我不得不忍受的事情，但这不是问题。
问题是实例化 my_thread具有该功能。我写了my_thread<int(Foo*, double)> thr(&Foo::bar, this, 3.14);进入 Visual Studio 2015 并提示

error C2664: 'my_thread<int (Foo *, double)>::my_thread(my_thread<int (Foo *, double)> &&)': cannot convert argument 2 from 'Foo *const ' to 'Foo *&&'

我尝试了一些施法魔法，但后来我发现，通过 &*this而不是 this有效。

我很高兴找到解决方案(或者至少是可以在 Windows 上编译和运行的解决方案)，因此我决定在 Linux 上使用 G++ 进行尝试。我使用了相同的代码(使用 &*this )，但是 G++ 对我很生气，因为

In member function 'void Foo::SomeFunction()': error: no matching function for call to ‘my_thread<int(Foo*, double)>::my_thread(int (*)(Foo*, double), Foo* const, double&)’
note: candidates are: my_thread(F&&, Input&&...)
note: template argument deduction/substitution failed:
note: cannot convert ‘this’ (type ‘Foo* const’) to type ‘Foo*&&’

我很惊讶我得到了与以前几乎相同的错误。我编辑回来了&*this只是this我能够在 Linux 下的 G++ 上编译和运行它。

我的问题是:
谁是对的？ G++ 4.9.2 还是 MVS2015？我该如何解决，让我的代码可以在两个平台上运行？
或者，我是否使用了错误的方法？ std::thread 是如何实现的，以便它知道，当传递非静态成员函数时，它将需要指向该类实例的指针作为参数？

---

编辑
我正在添加更多代码，以便我的意图更加清晰。

template<typename F> struct my_thread; // std::function like syntax

template<typename Return, typename... Input>
struct my_thread<Return(Input...)>
{
    struct thread_data
    {
        template<typename F>
        thread_data(F&& _func, Input&&... _input) : func(std::forward<F>(_func)), input(std::forward<Input>(_input)...) { }

        std::function<Return(Input...)> func;
        std::tuple<Input...> input;
    };

    template<typename F>
    my_thread(F&& _func, Input&&... _input) : data(std::forward<F>(_func), std::forward<Input>(_input)...) { }

    thread_data data;
};

Answer 1

这里:

template<typename F>
my_thread(F&& f, Input&&... value)

您不是在推导“通用引用”，而是对 Input... 参数的右值引用(这是您想要的吗？)。在这里，对于 Input = Foo*, double，您的构造函数读取

template<typename F>
my_thread(F&& f, Foo*&& value1, double&& value2)

这解释了 Foo*&& 部分。现在，根据this question ，this 指针永远不是左值，因此应该有 Foo* 类型(不是 Foo* const) ，并且应该绑定(bind)到 Foo*&&。这似乎是一个 MSVC 错误。

[关于使用 &*this 时的 GCC 行为，我不知道。]