How can i implement CreateThread - LPTHREAD_START_ROUTINE type ThreadProc callback function inside a C++ Class

Question

Happy new year!

This is my baby steps in C++ world.

I used an example from learn.microsoft.com to create an example Win32 Console project which uses the WaitForMultipleObjects function to persist until all worker threads have terminated. All worked great!

Things get complicated (argument of type DWORD (Thread::*)(LPVOID lpParam) is incompatible with parameter of type "LPTHREAD_START_ROUTINE") when i start to try to port the functionality of the concept inside a class which is similar like this:

    class Threads
    {
    
     private:

        HANDLE comThreads[1];

        DWORD WINAPI closeThreadProc(LPVOID lpParam)
        {
            // lpParam not used in this example.
            UNREFERENCED_PARAMETER(lpParam);
            printf("Thread %d exiting\n", GetCurrentThreadId());
            return 1;
        }
    
        BOOL CreateThreads(void)
        {
            DWORD dwThreadID;
            
            comThreads[0] = CreateThread(
                NULL,              // default security
                0,                 // default stack size
                closeThreadProc,   // Close thread function
                NULL,              // no thread parameters
                0,                 // default startup flags
                &dwThreadID);
        }

     public:
        
         void Init()
         {
             CreateThreads();
         }
    }

I will try to use this class to create a Dynamic-link library(DLL).

While i am searching the answer to my own question. I would like to ask you:

1. Is this even possible?
2. If it is possible. How can i achieve this, without loosing the underlying concept?

Thank you!

Edit:

Sorry for forgetting to tell if is it possible to make this, without making DWORD WINAPI closeThreadProc(LPVOID lpParam) static!

I did try to make it static before i posted the Question and things became even more wild (I barely forced to make everything in the class static).

I think this is the C++'s way to punish a rookie.

Answer 1

The LPVOID argument is there for a reason. The trick is to make the callback a static member but pass this as the extra parameter. You can then cast the LPVOID argument back to your object and call the method you want to. Some code will make it clearer

static DWORD WINAPI closeThreadProcCallback(LPVOID lpParam)
    {
        return static_cast<Threads*>(lpParam)->closeThreadProc();
    }

BOOL CreateThreads(void)
    {
        DWORD dwThreadID;
        
        comThreads[0] = CreateThread(
            NULL,              // default security
            0,                 // default stack size
            closeThreadProcCallback,   // Close thread callback function
            this,              // this object is the thread parameter
            0,                 // default startup flags
            &dwThreadID);
    }

EDIT added WINAPI as suggested by Tomer W.

Answer 2

a threadStartfunction cant be _thiscall, and have to be _stdcall,
therefore i'd declare a static private method to pass your call to your object, i use the lpParameter to pass the object to the static function.

class Threads
{
private:

    HANDLE comThreads[1];

    static DWORD WINAPI staticThreadProc(LPVOID lpParam)
    {
        Threads& callingThread = *reinterpret_cast<Threads*>(lpParam);
        return callingThread.closeThreadProc();
    }

    DWORD closeThreadProc()
    {
        printf("Thread %d exiting\n", GetCurrentThreadId());
        return 1;
    }

    BOOL CreateThreads(void)
    {
        DWORD dwThreadID;

        comThreads[0] = CreateThread(
            NULL,              // default security
            0,                 // default stack size
            staticThreadProc,   // Close thread function
            this,              // no thread parameters
            0,                 // default startup flags
            &dwThreadID);
    }

public:

    void Init()
    {
        CreateThreads();
    }
}