Unable to use std::thread - Part 2

[ClobberXD]

I had already created a similar topic, but it has become very old, so I started a new one. I tried to create a thread this way:

class MyClass
{
  void Func()
  {
  }
  void Func2()
  {
    .
    .
    
    std::thread t(Func);
    
    t.join();
  }
}

Here's the error:

Quote

 non-standard syntax; use '&' to create a pointer to member

So I ended up doing this:

std::thread t(&Func);

but now another error has surfaced:

Quote

 '&': illegal operation on bound member function expression

 

I still don't understand, what am I doing wrong here?

Edited April 28, 2017 by Anand_Geforce

[2FA]

What compiler are you using as well as compiler flags?

[fizzlesticks]

Please post your actual code, not something that looks kind of similar.

[Pinguinsan]

In your example, you show a non-class function (void Func()), but the compiler says Func() is a member function. Use the pointer-to-member-function syntax, and pass a reference to your class instance as the second parameter to the std::thread::constructor

 

#include <iostream>
#include <thread>
#include <chrono>

class MyClass
{
public:
	void doStuff() { std::cout << "Hello, World" << std::endl; }
};

int main()
{
	//A couple of things to note here. First, the pointer-to-member-function syntax is
	//&ClassName::functionName. Second is that to start a thread on a class member function, you must remember
	//that when you call a member function, there is an implicit "this" pointer. So everytime you call a member function,
	//you will have the this pointer available to you. Thus, you must include a reference/pointer to the 
	//class instance as the second argument to a std::thread constructor (how would the compiler know which instance it refers to?)
	MyClass myClass;
	std::thread runThisAsync{&MyClass::doStuff, &myClass};
	std::this_thread::sleep_for(std::chrono::milliseconds(2000));
	runThisAsync.join();
}

 

[ClobberXD]

Maybe I over-simplified it! I'll edit my first post...

[Pinguinsan]

You must use pointer-to-member-function syntax when passing an instance level method (ie non-static, tied to an instance of MyClass), as well as the "this" pointer when creating a std::thread to an instance level member function.So change

std::thread t(&Func);

to

std::thread t(&MyClass::Func, this);

[ClobberXD]

On 4/29/2017 at 3:38 AM, Pinguinsan said:

You must use pointer-to-member-function syntax when passing an instance level method (ie non-static, tied to an instance of MyClass), as well as the "this" pointer when creating a std::thread to an instance level member function.So change

std::thread t(&Func);

to

std::thread t(&MyClass::Func, this);

That worked! Thanks!

 

So what's actually happening is that since Func() is in a class, I've got to pass another arg. to std::thread::thread which is the 'this' pointer... right?

[Pinguinsan]

1 hour ago, Anand_Geforce said:

That worked! Thanks!

 

So what's actually happening is that since Func() is in a class, I've got to pass another arg. to std::thread::thread which is the 'this' pointer... right?

Yep, you got it! One of the weird things that you don't really learn anywhere is why the "this" keyword is available in every member function, and it's because when you have a class member like:

class MyClass
{
public:  
    void Func();
};

The ACTUAL signature to the member, generated by the compiler is

class MyClass
{
public:
    void Func(MyClass *this);
};

And any time you call from any other class method, the compiler automatically adds the "this" pointer, so you don't have to:
 

void MyClass
{
public:
	void OtherFunc() 
	{ 
	    this->Func(); //Notice I don't need to include "this" when calling Func() 
	}
    void Func() { }
};

And indeed, you can't include the "this" pointer even if you wanted to, as it is implicit the the compiler.

[Unimportant]

3 hours ago, Anand_Geforce said:

That worked! Thanks!

 

So what's actually happening is that since Func() is in a class, I've got to pass another arg. to std::thread::thread which is the 'this' pointer... right?

 

1 hour ago, Pinguinsan said:

Yep, you got it! One of the weird things that you don't really learn anywhere is why the "this" keyword is available in every member function, and it's because when you have a class member like:

class MyClass
{
public:  
    void Func();
};

The ACTUAL signature to the member, generated by the compiler is

class MyClass
{
public:
    void Func(MyClass *this);
};

And any time you call from any other class method, the compiler automatically adds the "this" pointer, so you don't have to:
 

void MyClass
{
public:
	void OtherFunc() 
	{ 
	    this->Func(); //Notice I don't need to include "this" when calling Func() 
	}
    void Func() { }
};

And indeed, you can't include the "this" pointer even if you wanted to, as it is implicit the the compiler.

And the reason, should anyone be interested, is that a instance of a class only contains the class's data (*). You can test this:

class Foo
{
	int bar;
  
public:
  
  	// Add as much member functions as you like ...
  
};

//You'll always get this...
sizeof(Foo) == sizeof(int)

If you have a million instances of this class you'll have a million int's, but the code for the member functions will exist only once, because it is always the same, only the data of a class changes.

That means, under the hood, this code must always receive a pointer to the instance data to work on.

 

(*) With some possible exceptions, such as a polymorphic class, which will probably also contain a vtable or some other extra data for the runtime dispatch mechanism.