Re: Accessing non-static class members fom static methods (About an alternative)
I read all your replies and try to explain some points about my approac:
- My sample class (Foo) is only an axample and it should be instantiated as
a singleton. I will use a class like this as a Windows Threadpool wrapper
and while every process can have only one threadpool (before Vista) there is
no reason to create more than one instance.
- Why static? Because the only way to pass a class method to
QueueUserWorkItem () is making it static. Well, but if I make it static I
should meke every members it access static also. Very bad! QueueUserWorkItem
() expects only one parameter and the solution seems to pass "this" as its
only parameter. But I have a contex pointer which will be used by the
threadpool threads to execute my work. If I pass "this" as parameter how can
I pass the context pointer? One solution is creating a wrapper struct and
passing it to threadpool :
Param * lpParam = new Param;
lpParam->lpvThis = this;
lpParam->lpvParam = lpContext;
Now I can pass "lpParam" and access both "this" and the "context". But the
promlem here is I should make one extra allocation and deallocation for
every queued work. I will use this class with an IOCP based server and
thousands of works will be queued and processed. So extra allocations and
deallocations will harm performance.
By caching "this" as a static pointer, I will eliminate this performance
penalty and pass only "context" object as I can access "this" via static
I think reentrancy and other issues can be applied in both cases. There is
no defference between passing "this" as a parameter and caching it in a
static member as long as the object is singleton.
Am I right?
Thanks for your replies.
"K?r?at" <email@example.com> wrote in message
We generally access non-static class members from a static method by
passing "this" to that static method and accessing non-static members over
My alternative is caching "this" into a static member and use that static
member whenever you need to access non-static members. Is there anything
bad about this solution?
static Foo * lpThis;
// Some initializations...
lpThis = this; // Last statement in the constructor...
static void doJob ()
// Now we can access all non-static members over static "lpThis"...
Foo * Foo::lpThis;
Thanks in advance.