threads with member functions

[xixpsychoxix]

this is probably a stupid question with either a really easy answer or an "are u kidding? that can't be done!!!" answer, but how do i use _beginthread with a class member function? i've tried:

class my_class
{
 void function_1 (void)
 {
  cout << "Hello, world!";
 }
};

int main ()
{
 my_class test;

 _beginthread (my_class.function_1, 0, NULL);

 return 0;
}

to no avail. can anyone tell me how to achieve this?

[abachler]

_beginthread (my_class.function_1, 0, NULL);

_beginthread (test.function_1, 0, NULL);

[brewbuck]

_beginthread (test.function_1, 0, NULL);

How is the "this" pointer going to make it into that call? Or does _beginthread do some special magic?

When I've done this, I've used a thunk function:

void ThunkMethodCall(void *obj)
{
    MyClass *myObj = (MyClass *)obj;
    myObj->Foo();
}

[abachler]

well, generally you pass this as one of the arguments. My personal style is to have it as a seperate function, not part of the class, and simply pass this, which is recast inside the thread.

[Overlord]

Or you can make the member function static, but you also need to pass this to it.

[Elysia]

I'm generous today, so here's my typical C++ CreateNewThread code:

#include <windows.h>
#include <iostream>

template<typename ParamType, typename ClassType, typename ReturnType>
	struct ThreadParams
{
	ParamType* Param;
	ClassType* Instance;
	ReturnType (ClassType::* Function)(ParamType* Param);
	HANDLE hProcess;
};

template<typename ParamType, typename ClassType, typename ReturnType>
	DWORD WINAPI ThreadFnc(void* pParam)
{
	ThreadParams<ParamType, ClassType, ReturnType>* pParams =
	(ThreadParams<ParamType, ClassType, ReturnType>*)pParam;
	(pParams->Instance->*pParams->Function)(pParams->Param);
	CloseHandle(pParams->hProcess);
	delete pParams;
	return 0;
}

template<typename ParamType, typename ClassType, typename ReturnType>
	DWORD CPPCreateThread(ReturnType (ClassType::* Function)(
	ParamType* Param), ClassType* Instance, ParamType* Param)
{
	ThreadParams<ParamType, ClassType, ReturnType>* pParams =
		new ThreadParams<ParamType, ClassType, ReturnType>;
	pParams->Param = Param;
	pParams->Instance = Instance;
	pParams->Function = Function;
	HANDLE hProcess = CreateThread(NULL, NULL,
		&ThreadFnc<ParamType, ClassType, ReturnType>, pParams,
		CREATE_SUSPENDED, NULL);
	if (hProcess == NULL)
		return GetLastError();
	pParams->hProcess = hProcess;
	ResumeThread(hProcess);
	DWORD dwErr = GetLastError();
	if (dwErr != ERROR_SUCCESS)
	{
		CloseHandle(hProcess);
		delete pParams;
	}
	return dwErr;
}

// THIS IS HOW YOU USE IT, FROM HERE ON OUT
class foo
{
public:
	foo() { CPPCreateThread<void>(&foo::ThreadFunc, this, NULL); }
	void ThreadFunc(void*) { std::cout << "Hi! This is inside the thread!"; };
};

int main() { foo f; Sleep(1000); }

There. Does that help?

[CornedBee]

Whatever you do, don't use _beginthread. It's conceptually broken. Use _beginthreadex if you want the CRT (you probably do) or CreateThread if you don't.

[adeyblue]

Does that help?

Great stuff, thanks for posting. The only problem I have is that it's in the wrong thread, I think you wanted this one

[Elysia]

Now why would you think something like that?

[CornedBee]

I see four problems with your code, Elysia.

1) You're calling the thread handle hProcess. This is the least of the problems, though, just a confusing name.
2) You're not using _beginthreadex. If you link statically against the CRT, that will leak. Not good for a generic utility.
3) You're passing the returned handle to the created thread. What for? It's your handle, just close it. If the created thread wants a real handle to itself, it can DuplicateHandle(GetCurrentThread()). Your thread stub doesn't even use the handle!
4) You're leaking pParams if thread creation fails.

[Elysia]

1) I don't know why I named it hProcess... Perhaps I was confusing it with something else. My mistake.
2) That is a good point. I didn't know about that before...
3) Well... I used it to close the handle from the thread itself. I dunno if it's possible to do it right after the call or not.
4) Oops!

So I revamped the code a little to get rid of the criticism.
EDIT: Posting fixed code below.

[adeyblue]

Here's 4 more

1. Still leaking pParams if ResumeThread fails
2. Leaking at least the thread stack on Vista+ if ResumeThread fails (call TerminateThread to get rid of it).
3. Relying on GetLastError to return 0 when a function succeeds isn't guaranteed (especially not for a CRT function). Checking the return value is easier.

And since this is intended for C++
4. pParam will leak if the thread function throws.

[Elysia]

Very well. Revised code.
I hope this one gets rid of all criticism.

#include <windows.h>
#include <iostream>
#include <process.h>
#include <memory>

namespace Stuff
{
	typedef unsigned int (__stdcall CThreadFunction)(void*);
	template<typename T> CThreadFunction* CThreadFunctionCast(
		unsigned int (__stdcall* pFunction)(T*))
	{
		return reinterpret_cast<CThreadFunction*>(pFunction);
	}

	class auto_handle
	{
	public:
		auto_handle(HANDLE Handle): m_h(Handle) {}
		~auto_handle() { CloseHandle(m_h); }
		HANDLE get() { return m_h; }

	private:
		HANDLE m_h;
	};

	template<typename T> class reference_wrapper
	{
		reference_wrapper(T& value): m_value(value) {}

	private:
		T& m_value;
	};

	int get_err_no()
	{
		int temp;
		_get_errno(&temp);
		return temp;
	}

	namespace Thread
	{
		struct Error
		{
			int CreationError;
			DWORD ResumeError;
			DWORD TerminateError;
		};

		template<typename ParamType, typename ClassType, typename ReturnType>
			struct Params
		{
			ParamType* Param;
			ClassType* Instance;
			ReturnType (ClassType::* Function)(ParamType* Param);
		};

		template<typename ParamType, typename ClassType, typename ReturnType>
			unsigned int __stdcall ThreadFnc(
			Params<ParamType, ClassType, ReturnType>* pParam)
		{
			(pParam->Instance->*pParam->Function)(pParam->Param);
			delete pParam;
			return 0;
		}

		template<typename ParamType, typename ClassType, typename ReturnType>
			Error Create(ReturnType (ClassType::* Function)(ParamType* Param),
			ClassType* Instance, ParamType* Param)
		{
			const DWORD dwFail = static_cast<DWORD>(-1);
			Error ReturnErr = {};
			std::auto_ptr< Params<ParamType, ClassType, ReturnType> > pParams(
				new Params<ParamType, ClassType, ReturnType>);
			pParams->Param = Param;
			pParams->Instance = Instance;
			pParams->Function = Function;
			Stuff::auto_handle hThread = reinterpret_cast<HANDLE>(
				_beginthreadex(NULL, 0, Stuff::CThreadFunctionCast(
					&ThreadFnc<ParamType, ClassType, ReturnType>),
				pParams.get(), CREATE_SUSPENDED, NULL) );
			if (hThread.get() == 0)
			{
				ReturnErr.CreationError = Stuff::get_err_no();
				return ReturnErr;
			}
			if (ResumeThread(hThread.get()) == dwFail)
			{
				ReturnErr.ResumeError = GetLastError();
				if ( !TerminateThread(hThread.get(), 1) )
					ReturnErr.TerminateError = GetLastError();
				return ReturnErr;
			}
			pParams.release();
			return ReturnErr;
		}
	}
}

class foo
{
public:
	foo() { Stuff::Thread::Create<void>(&foo::ThreadFunc, this, NULL); }
	void ThreadFunc(void*) { std::cout << "Hi! This is inside the thread!"; };
};

int main() 
{
	foo f;
	Sleep(1000);
}