havman56
asked on
making thread body as member function
In C++ how to create a thread, whose thread body is member function (not static ) of the
class, so that when class object is created, that particular thread should
access only its member variables, which may be the case with as many class
objects created.
class, so that when class object is created, that particular thread should
access only its member variables, which may be the case with as many class
objects created.
I am afraid you can't do it. What is the problem with static functions?
struct A
{
void Realwork();
static void Run(void*)
}
void A::Run(void* parm)
{
reinterpret_cast<A*>(parm) ->Realwork ();
}
A object;
makethread(&A::Run, reinterpret_cast<void*>(&A ))
{
void Realwork();
static void Run(void*)
}
void A::Run(void* parm)
{
reinterpret_cast<A*>(parm)
}
A object;
makethread(&A::Run, reinterpret_cast<void*>(&A
>KangaRoo
Actually the question is how to do it without "static"
Actually the question is how to do it without "static"
ASKER CERTIFIED SOLUTION
membership
This solution is only available to members.
To access this solution, you must be a member of Experts Exchange.
And that is without statics, well, not in the interface. The use of a static member is now a hidden implementation detail :)
void __cdecl run_thread(void *p)
{
Class *c = (Class*)p;
p->run();
delete r;
}
class Class
{
void run()
{
printf("RUN");
}
};
the latter on
Class *c = new Class
_beginthread(run_thread,0, (void*)c);
this would/should work on windows compilers
{
Class *c = (Class*)p;
p->run();
delete r;
}
class Class
{
void run()
{
printf("RUN");
}
};
the latter on
Class *c = new Class
_beginthread(run_thread,0,
this would/should work on windows compilers
Consider the following more object oriented approach:
1. Define an interface for performing thread actions:
struct Action
{
virtual void operator() = 0;
virtual void ~Action() { };
};
2. Define a general thread creating function and ThreadProc which invoke a functor:
HANDLE CreateThreadObject(Action* pAction)
{
return CreateThread(0, 0, GeneralThreadProc, pAction, 0, 0);
};
static void GeneralThreadProc(void * prm)
{
reinterpret_cast<Action*>( prm)->();
};
3. Each time you want to do some task in another thread simply derive from Action:
struct SomeWorkerAction : public Action
{
void operator()
{
MessageBox(0, "This is done on another thread", 0, 0);
delete this;
};
};
-- or --
struct SomeWorkerActionWithParams : public Action
{
string data_;
SomeWorkerActionWithParams (const string& data) : data_(data) { };
void operator()
{
MessageBox(0, "This is done on another thread", data_.c_str(), 0);
delete this;
};
};
And spawn a thread to run it:
CreateThreadObject(new SomeWorkerAction);
CreateThreadObject(new SomeWorkerActionWithParams ("use this param"));
This approach is a lot nicer. It's easier to pass parameters to the thread and it's also easier to use when implementing more complicated MT applications. (For instance, you can store a queue of Action* and invoke them from a pool of threads.)
btw, the code is just a thought. I didn't compile it or anything so don't be suprised if it has errors. I *do* happen to have a private Thread Pool library which uses a similar idiom.
1. Define an interface for performing thread actions:
struct Action
{
virtual void operator() = 0;
virtual void ~Action() { };
};
2. Define a general thread creating function and ThreadProc which invoke a functor:
HANDLE CreateThreadObject(Action*
{
return CreateThread(0, 0, GeneralThreadProc, pAction, 0, 0);
};
static void GeneralThreadProc(void * prm)
{
reinterpret_cast<Action*>(
};
3. Each time you want to do some task in another thread simply derive from Action:
struct SomeWorkerAction : public Action
{
void operator()
{
MessageBox(0, "This is done on another thread", 0, 0);
delete this;
};
};
-- or --
struct SomeWorkerActionWithParams
{
string data_;
SomeWorkerActionWithParams
void operator()
{
MessageBox(0, "This is done on another thread", data_.c_str(), 0);
delete this;
};
};
And spawn a thread to run it:
CreateThreadObject(new SomeWorkerAction);
CreateThreadObject(new SomeWorkerActionWithParams
This approach is a lot nicer. It's easier to pass parameters to the thread and it's also easier to use when implementing more complicated MT applications. (For instance, you can store a queue of Action* and invoke them from a pool of threads.)
btw, the code is just a thought. I didn't compile it or anything so don't be suprised if it has errors. I *do* happen to have a private Thread Pool library which uses a similar idiom.
I think this is what exactly you want:
http://www.codeproject.com/useritems/callback_adapter.asp
Almost a perfect solution.
http://www.codeproject.com/useritems/callback_adapter.asp
Almost a perfect solution.