std::thread constructor Is there a difference between passing a pointer and passing by ref?

Question

When creating a thread that calls a member function, is there a difference between passing a pointer to the current class or passing a reference?

From the example below, does method1 behave the same as method2? Are there any differences?

class MyClass
{
public:
    MyClass(){};
    ~MyClass(){};
    void memberFunction1()
    {
        //method 1
        std::thread theThread(&MyClass::memberFunction2, this, argumentToMemberFunction2)

        //method 2
        std::thread theThread(&MyClass::memberFunction2, std::ref(*this), argumentToMemberFunction2)
    }
    void memberFunction2(const double& someDouble){};
}

Answer 1

No, there are no differences, but note that using a reference wrapper has only become possible with the acceptance of LWG 2219 as a defect report at the Oct 2015 WG21 meeting.*

Using std::ref may help in cases where you have a named object instance rather than this, since this is quite easy to spell. But consider the following situation, in which you'd like to stay nicely const-correct:

A a;
std::thread(&A::foo, std::cref(a), 1, 2);

This may be easier to read than:

std::thread(&A::foo, &(const_cast<const A&>(a)), 1, 2);
std::thread(&A::foo, &as_const(a), 1, 2);
std::thread(&A::foo, const_cast<const A*>(&a), 1, 2);

_{*) Vendors that keep distinct language dialects around, like GCC's and Clang with the -std flag), will typically consider defects to apply to all dialects and "fix" the implementations. Defects are things that "were always meant to be the way we say now".}