Passing arguments to _beginthread within class function

Question

I've been using _beginthread within my (windows) C++ class to create threads. As I have learned, to use _beginthread and pass a member function within a class, there is a rather obtuse wrapping protocol that has to be followed, for example:

class MyClass
{
public:
    void fun_1()
    {  
        _beginthread(&MyClass::fun_2_wrapper, 0, static_cast<void*>(this));
    }

private:
    void fun_2()
    {
        printf("hello");  
    }  

    static void __cdecl fun_2_wrapper(void* o)
    {
        static_cast<MyClass*>(o)->fun_2();
    }
};

I have been having trouble translating this model to one that accepts arguments for my thread function. For instance, if I wanted my thread function to instead be:

void fun_2(int a)

How would I properly adapt my function calls? (Note, I am trying to accomplish this without boost::thread or similar libraries for project consistency)

possible duplicate of [Pass more than one argument to CreateThread](http://stackoverflow.com/questions/575695/pass-more-than-one-argument-to-createthread) — Raymond Chen, Apr 06 '13 at 01:49
I agree a duplicate. Specifically in this case: create a struct containing {this, a}. Then in fun_2(void*x) cast x to the struct and then pick out this and a. — Wandering Logic, Apr 06 '13 at 02:27
So I need to keep 'this' as part of the new struct... Would I static_cast the struct containing {this, a} in my _beginthread call? — cmgurba, Apr 06 '13 at 02:58
Yes, if you did it that way you should static_cast the struct. But I was wrong in my comment before. You already have a struct (MyClass is a class after all). The easier way in your case is to just add "int a" as private member of MyClass. Then the call in fun_2_wrapper can just be: `MyClass* mco=static_cast(o); mco->fun_2(mco->a);` — Wandering Logic, Apr 06 '13 at 11:22
Use boost::thread or std::thread, depending on what your compiler supports. You are reinventing a wheel that isn't nearly as round as the one developed by others before. — Ulrich Eckhardt, Apr 06 '13 at 11:59

score 0 · Answer 1 · answered Aug 28 '18 at 14:21

You can wrap arguments which would be passing to a struct, then pass the struct for function.

example:

#include <Windows.h>
#include "stdio.h"
#include "stdlib.h"
#include <process.h>

class TestWrapperMultThreadToClass
{
public:
    TestWrapperMultThreadToClass(int ThreadNum)
    {
        _ThreadNum = ThreadNum; // how many thread we would create
        TestTimes = ThreadNum * 2;
    }

    ~TestWrapperMultThreadToClass()
    {

    }

    bool TestMultThreadSendParam()
    {
        tb = new ThreadBlockParam[_ThreadNum];
        for (int i = 0; i < _ThreadNum; i++) // initial
            (tb + i)->IsIdle = true;

        int ThreadIndex = 0, nowThread = 0;
        unsigned int ThreadId_For_Beginthreadex_Function = 0;
        for (int i = 0; i < TestTimes; i++)
        {
            ThreadId_For_Beginthreadex_Function = static_cast<unsigned int>(i);
            nowThread = i;

            // wrap arguments
            (tb + nowThread)->ThreadIndex = ThreadId_For_Beginthreadex_Function;
            (tb + nowThread)->InIterativeTimes = i;
            (tb + nowThread)->IsIdle = false;
            (tb + nowThread)->_wrap = (void*) this;
            _beginthreadex(NULL, 0, FunctionCalledByThread, (tb + nowThread), 0, &ThreadId_For_Beginthreadex_Function);
        }

        IsAllThreadComeBack(tb, _ThreadNum); // check whether all threads come back

        return true;
    }

private:
    int _ThreadNum, TestTimes;

    typedef struct _ThreadBlockParam
    {
        int ThreadIndex;
        int InIterativeTimes;
        bool IsIdle;
        void* _wrap;
    }ThreadBlockParam;
    ThreadBlockParam *tb;

    static unsigned int __stdcall FunctionCalledByThread(void *ptr_this)
    {
        ThreadBlockParam *_tb = static_cast<ThreadBlockParam*>(ptr_this);
        TestWrapperMultThreadToClass *_this = (TestWrapperMultThreadToClass*)(_tb->_wrap);

        _this->Test(_tb);
        return 1;
    }

    void Test(ThreadBlockParam* _tb)
    {
        ThreadBlockParam *temp = _tb;
        int ThreadId = GetCurrentThreadId();
        char Msg[200];

        Sleep(1000);
        sprintf(Msg, "In %d-th thread, thread id = %d!\n", temp->ThreadIndex, ThreadId);
        printf(Msg);
        Sleep(5000); // wait few second to check whether execute with different thread.

        temp->IsIdle = true;
    }

    bool IsAllThreadComeBack(ThreadBlockParam *tb, int ThreadNum)
    {
        int count = 0;

        while (count < ThreadNum)
        {
            if ((tb + count)->IsIdle == true)
                count++;
        }
        return true;
    }

};

int main()
{
    TestWrapperMultThreadToClass *Test = new TestWrapperMultThreadToClass(8);
    Test->TestMultThreadSendParam();

    printf("Multiple thread wrapper to class testing is finishing!\n");

    system("pause");
    return 0;
}

Passing arguments to _beginthread within class function

1 Answers1