Re: taking address of protected base member function not possible?? what to do?
Hi!
Jonathan Lee schrieb:
I'm surprised this works!? I'm guessing this is resolving the virtual
function implemented in the derived class and providing you with that
address. Depends on how you actually wrote the code.
Yes, it resolves to a virtual function call, as within a Base function I
evaluate the expression "&Base::assignIDs".
I think what you want is a static member function for assignIDs, since
you're passing counter by reference anyway.
Yes, this really does solve the problem. Although I suspect you mean
something different than I do, I was able to solve the problem using a
static method:
struct Base
{
virtual ~Base() {}
unsigned getID() const { return id; }
protected:
unsigned id;
virtual void assignIDs(unsigned &counter) =0;
static void callAssignIDs(Base& b, unsigned &counter)
{ b.assignIDs(counter); }
};
Within derived classes I can take the address of the static method and
call it for each child.
Or maybe you want public
inheritance? That should give you access to the parent's protected
members, but you'll have to be careful with that.
I actually have public inheritance. Without specifiers in the base class
list a struct will inherit public.
Also, you may have your reasons for it, but do you really want the
assignID function and the id variable in separate classes? You've
split your implementation. Besides, the assignIDs function of your
child above doesn't do anything special. Why not bundle all your ID
related code in one class. I think you'd have less trouble.
Yes, I've split the implementation. The reason is Base does not know
anything about possible children. Only the derived class ContainerBase
knows. So only the derived class can properly enumerate the children.
And there are more classes (that I left out here) which can have
children. It is not reasonable to bundle the children related code in
Base, but it is reasonable to have the derived class set its own id
althought the attribute is inherited from Base.
But maybe I can move the assignment into the Base class. I would have to
rename the functions now. I left the name for now, so you can better
understand the change:
struct Base
{
virtual ~Base() {}
unsigned getID() const { return id; }
protected:
unsigned id;
virtual void assignIDs(unsigned &counter) { /*NO CHILDREN*/ };
static void callAssignIDs(Base& b, unsigned &counter)
{
id = counter++; //ASSIGN HERE
b.assignIDs(counter); //PROCESS POSSIBLE CHILDREN
}
};
struct ContainerBase : Base
{
protected:
virtual void assignIDs(unsigned &counter)
{
using namespace boost;
//CALL FOR EACH CHILD:
std::for_each(children.begin(), children.end(),
bind(&Base::callAssignIDs, _1, ref(counter)));
}
boost::ptr_deque<Base> children;
};
To me this seems to be the cleanest solution (given proper method
names). It is now even an advantage that the dervied class cannot call
the virtual assignIDs function for other objects. This forces the use of
the static function, that will assign to "id" properly. And "id" can now
even be made private.
Frank
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]