[boost] Re: dynamic inheritance with FC++

From: Larry Evans (cppljevans_at_[hidden])
Date: 2004-02-28 09:08:52

On 02/27/2004 11:01 PM, Brian McNamara wrote:
> On Fri, Feb 27, 2004 at 09:07:10PM -0600, Larry Evans wrote:
> >
[snip]
> You mentioned a couple problems with the regexp code:
> 
> 
>>there's a pointer from subtype to supertype and back (more memory) and
>>the virtual functions in supertype must be delegated to in the subtype
>>(more programmer time).
> 
> 
> So I tried to find a solution where you didn't have to write any
> call-forwarding routines, and where the delegate doesn't have to store
> a pointer back to the original object.  I used inheritance to solve one
> of the problems (no more need to write a forwarding function: "C"
> inherits "f"), and used an explicit extra "self" pointer parameter to
> solve the other problem (way to "get back" to the original object) as
> well as to recover the information intrinsically lost when switching
> from member functions to function objects.
Thanks. This clears up a lot.
> 
> Now "C" can change the "object delegated to" just by assigning a
> different delegate object to its own "B" subobject:
> 
>    dynamic_cast<B&>(c) = b1;    // delegate to b1
>    ...
>    dynamic_cast<B&>(c) = b2;    // delegate to b2
But doesn't this copy b2's "values" into c's B part; hence,
c doesn't really delegate to b2.  Adding:

   B::operator=(B const& b_){ f=b_.f;}

and running will show, I think, that c doesn't delegate to
b2 after the above assignment.
> 
> That said, I admit I didn't look very carefully at the regexp code, so
> I may be missing some important aspect/intention of what you want to
> do with all of this.  So let me know, both if my explanation above
> clarified what I was trying to do, and if it does or does not
Yes it does. Thanks again.
> accomplish what you're seeking.
No :( .  The problem I'm trying to solve involves a "Dual Inheritance
Heirarchy" ( http://www.objectmentor.com/resources/articles/dih.pdf )
but avoids copying the whole tree by just copying a single pointer
to the root of the tree (as done by regexp_first_constructor )
but also applying a similar transformation to all the children
as done by, for example:

   regexp_first_constructor::visit(regexp_tree_seq*a_tree)

Maybe there's an existing design pattern for this, but I haven't yet
seen it or don't yet recognize it.  However, there are near
matches, e.g. the intelligent children
( http://patterndigest.com/patterns/IntellegentChildren.html ).
This maybe an exact match, but I need more time to understand it
and my requirements to see the difference, if any.