Re: Diamond Inheritance and STL

From:

"Alf P. Steinbach" <alfps@start.no>

Newsgroups:

comp.lang.c++

Date:

Tue, 07 Apr 2009 14:17:09 +0200

Message-ID:

<grfgbv$iik$1@news.motzarella.org>

* HGallon@teranews.com:

I have an application where I have visual elements which are a: Moving
or Stationary, and b: Static or Animated

//
using namespace std;

//
class element
{
public:
    virtual void Paint (HDC hDC);
};

//
class movingElement : public element
{
public:
    void Move ();
};

//
class animatedElement : public element
{
public:
    void Update (); // get next image in
                       // animated sequence
};

//
class movingAnimatedElement : public movingElement,
                              public animatedElement
{
};

So far, so good.

Well, no. You have two distinct base class objects of type 'element', one
belonging to movingElement and on to animatedElement. So if you try to call
'Paint' on a movingAnimatedElement the compiler will report an ambigious call:
did you mean to call the movingElement Paint or the animatedElement Paint?

And, noting that it doesn't make much sense to call *both* (which could be
arranged in the final bottom level class, but isn't practically meaningful), you
have a design level problem, not just a C++ implementation problem.

Adding "virtual" in the inheritance chain is /not/ a solution of that design
level problem -- for with 'element' a virtual base class you still have the
Paint problem.

Thus, the resolution hinges on what functionality you really ahve in
movingElement and in animatedElement.

I.e., does it really make sense to combine these two via multiple inheritance (I
think not, but could be, depending on what they really are).

Now I need a container to display all visual elements
sorted by e.g. Z-Order

//
class elementList
{
protected:
    list<element*> m_list;

public:
    virtual void addElement (element* pEl);
};

Now, when adding all elements into a sorted list

//
void fn ()
{
    element el;
    movingElement mEl;
    animatedElement aEl;
    movingAnimatedElement maEl;

    elementList elList;

    elList.addElement (&el); // ok
    elList.addElement (&mEl); // ok
    elList.addElement (&aEl); // ok
    elList.addElement (&maEl);
    Error C2594: 'argument' : ambiguous conversions from 'class
movingAnimatedElement*' to 'class element*'

}

C2594 is defined as "'operator' : ambiguous conversions from 'type1' to
'type1' No conversion from one specified type to the other was more
direct than any other. It may be necessary to define or specify an
explicit conversion."

If I convert maEl to a movingElement, I can't update the animated image
frame; if I convert it to an animatedElement, I can't move it. And I'd
rather not add "virtual void Move ()" to the definition of element and
everything derived from it. Any help, anyone?

You need to get concerete about what movingElement and animatedElement are.

For without that you can't solve the design level problem.

It's not a C++ problem, the solution is not "virtual" inheritance, it is a
design level problem, where at first I think it will be helpful for you to focus
on exactly what a Paint call on a movingAnimatedElement should result in.

Cheers & hth.,

- Alf

--
Due to hosting requirements I need visits to <url: http://alfps.izfree.com/>.
No ads, and there is some C++ stuff! :-) Just going there is good. Linking
to it is even better! Thanks in advance!