Re: Referencing the container object
On Feb 4, 2:29 am, "Alf P. Steinbach" <al...@start.no> wrote:
As is very common, it seems that you're focusing on an imagined (and unwo=
rkable)
technical solution to some problem that you haven't divulged.
Thanks anyway :) I'll try to consider other approaches.
Yes, imagined of course :) Trying "other approaches" means also trying
something that may be unexplored. If this method isn't workable, I'll
wont use it.
No, I've said everything apart specific stuff about what I'm doing:
all what I'm trying to get is the liberty for the subclasser to insert
functors in some object and having that functors to get automatically
the object's reference.
One would be that whatever you're trying to achieve would be better done =
with
simple virtual routines,
struct UserContainer
{
virtual void method() ...
};
Nope, because the functors are reusable and contains many other
informations. Putting them as standard methods doesn't fit.
Another would be that whatever you're trying to achieve would be better d=
one
with an explicit call syntax,
struct UserContainer
{
virtual void call( Functor& ... ) ...
};
This would be better (and by the way, actually my code works exactly
like this :).
But since my telepathic abilities have deteriorated somewhat in recent ye=
ars, it's difficult to say.
It would be simpler if you'd described what you're trying to achieve (and=
not some invented generalization thereof).
I'm trying to use functors objects as they would be methods in C++. (I
thought it was pretty clear in my first reply. Sorry)
There are many issues in trying to do this... For example, accessing
private members. That's why I always used struct and no class.
Because... It's easy: methods in C++ aren't objects, while functors
are.
Doing it with virtual methods as you wrote requires some work to the
user that I would like to eliminate.
For example, have to be instantiated:
Functor = functor(&userContainer);
have to be registered:
userContainer.register(functor);
has to be used:
userContainer.call(functor, params);
well, doing all this by hand is really boring, and wrong, because
"repetitive job is done by machines. If you're doing repetitive job,
you're doing it wrong" (cit. my C++ course teacher).
I would like to simulate the normal use of methods (and this was clear
from my example, wasn't it?)
struct MyObj { method_declaration } obj.
obj.use_as_normally(params); // Happy user :) Common way of doing
things = easy way of doing thins.
as you see, no need instantiate the method, no need of registering it,
no need of doing by hand all the things that I, implementer of the
library, could do with ease *one time*, removing this cumbersome job
from users' shoulders.
I'm not saying that this IS feasible in C++ or that this must be the
BEST way of doing it or that I MUST do it like this.
I _already did it_ "in a normal way", but it has flaws that I'd like
to remove. This is so far the best method I've found, and I'm trying
to get it done (if possible) in C++.
Your contribute is useful anyway, thanks.
~Ale