threads with member functions

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:

Code:

---


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?

Quote:

---

Originally Posted by xixpsychoxix

_beginthread (my_class.function_1, 0, NULL);

---

Code:

---


_beginthread (test.function_1, 0, NULL);

---

Quote:

---

Originally Posted by abachler

Code:

---


_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:

Code:

---

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

---

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.

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

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

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? :)

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.

Quote:

---

Originally Posted by Elysia

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 :)

Now why would you think something like that?

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.

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.

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.

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

Code:

---

#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);
}

---