Several base classes with identical virtual functions

Discussion in 'C++' started by Juha Nieminen, Apr 25, 2007.

  1. It occurred to me while developing an application: What happens
    if two (completely independent) base classes have the exact same
    virtual function, and then a derived class is derived from both,
    and this derived class implements that function? Will it work?
    Will it cause an error along the lines of "ambiguous function
    definition" or whatever?

    Well, I tried it, and it actually seemed to compile and work
    just as expected. Apparently this *is* a standardized behavior?
    Does this have some kind of name in the standard?


    #include <iostream>

    class Base1
    {
    public:
    virtual void method(int i) = 0;
    };

    class Base2
    {
    public:
    virtual void method(int i) = 0;
    };

    class Derived: public Base1, public Base2
    {
    public:
    virtual void method(int i)
    {
    std::cout << i << std::endl;
    }
    };

    int main()
    {
    Derived d;
    Base1& b1 = d;
    Base2& b2 = d;

    d.method(1);
    b1.method(2);
    b2.method(3);
    }
     
    Juha Nieminen, Apr 25, 2007
    #1
    1. Advertising

  2. Juha Nieminen wrote:
    > It occurred to me while developing an application: What happens
    > if two (completely independent) base classes have the exact same
    > virtual function, and then a derived class is derived from both,
    > and this derived class implements that function? Will it work?


    Sure.

    > Will it cause an error along the lines of "ambiguous function
    > definition" or whatever?


    No, why would it?

    > Well, I tried it, and it actually seemed to compile and work
    > just as expected. Apparently this *is* a standardized behavior?


    Yep.

    > Does this have some kind of name in the standard?


    Aside from "multiple inheritance" and "final overrider"?

    Generally speaking, what you do here is implement the _required_
    behaviour in the derived class. Both base classes mandate that their
    member functions are overridden, so you override them. Both base
    classes name their functions the same and provide the same interface
    (argument types). It's questionable as a design choice but from the
    language point of view there is nothing that would make it invalid.

    To understand this from the OOD point of view you need to make it
    a bit more real. I don't have a good example here, but imagine that
    you have

    class Wolf {
    virtual std::string speak() const { return "howl!"; }
    };

    class Man {
    virtual std::string speak() const { return "hello!"; }
    };

    class Werewolf : public Man, public Wolf {
    std::string speak() const {
    if (fulllmoon)
    return Wolf::speak();
    else
    return Man::speak();
    }
    };

    Here a 'Werewolf' actually implements the [non-required] behaviour
    to "speak" but extends it involving 'fullmoon' condition.

    >
    >
    > #include <iostream>
    >
    > class Base1
    > {
    > public:
    > virtual void method(int i) = 0;
    > };
    >
    > class Base2
    > {
    > public:
    > virtual void method(int i) = 0;
    > };
    >
    > class Derived: public Base1, public Base2
    > {
    > public:
    > virtual void method(int i)
    > {
    > std::cout << i << std::endl;
    > }
    > };
    >
    > int main()
    > {
    > Derived d;
    > Base1& b1 = d;
    > Base2& b2 = d;
    >
    > d.method(1);
    > b1.method(2);
    > b2.method(3);
    > }


    V
    --
    Please remove capital 'A's when replying by e-mail
    I do not respond to top-posted replies, please don't ask
     
    Victor Bazarov, Apr 25, 2007
    #2
    1. Advertising

  3. Victor Bazarov wrote:
    > To understand this from the OOD point of view you need to make it
    > a bit more real.


    I think I actually have a more useful idea for this. Consider:

    class TranslateableObject
    {
    public:
    void setTranslationPath(<some path definition>);
    void translateAlongPath(<by something>); // calls 'transform()'

    protected:
    virtual void transform(<eg. a transformation matrix>) = 0;

    private:
    <path definition>
    };

    class RotateableObject
    {
    public:
    void rotateBy(<some angle>); // calls 'transform()'

    protected:
    virtual void transform(<eg. a transformation matrix>) = 0;
    };

    class SomeObject: public TranslateableObject, public RotateableObject
    {
    ...

    protected:
    virtual void transform(<eg. a transformation matrix>);

    ...
    };

    Perhaps not *exactly* like this, but you get the idea?
     
    Juha Nieminen, Apr 26, 2007
    #3
  4. Juha Nieminen

    Marcus Kwok Guest

    Juha Nieminen <> wrote:
    > It occurred to me while developing an application: What happens
    > if two (completely independent) base classes have the exact same
    > virtual function, and then a derived class is derived from both,
    > and this derived class implements that function? Will it work?
    > Will it cause an error along the lines of "ambiguous function
    > definition" or whatever?
    >
    > Well, I tried it, and it actually seemed to compile and work
    > just as expected. Apparently this *is* a standardized behavior?
    > Does this have some kind of name in the standard?


    Victor has answered your question: if the most derived class implements
    the virtual function, then it shouldn't be a problem. However, if you
    are using multiple inheritence but you are using the default
    implementations for the virtual functions, then you will get the
    ambiguity error:


    #include <iostream>

    class First {
    public:
    virtual void print() const { std::cout << "First\n"; }
    };

    class Second {
    public:
    virtual void print() const { std::cout << "Second\n"; }
    };

    class Derived : public First, public Second { };

    int main()
    {
    Derived d;
    d.print();

    return 0;
    }

    virt.cpp
    virt.cpp(18) : error C2385: ambiguous access of 'print' in 'Derived'
    could be the 'print' in base 'First::print'
    or the 'print' in base 'Second::print'
    virt.cpp(18) : error C3861: 'print': identifier not found, even with argument-dependent lookup


    Therefore, when using multiple inheritence, it usually helps if the base
    classes are abstract (the virtual functions are pure). For the
    diamond-inheritence hierarchy issue, virtual base classes may help. See
    the "Virtual Base Classes" chapter of Stroustrup for more information.

    --
    Marcus Kwok
    Replace 'invalid' with 'net' to reply
     
    Marcus Kwok, Apr 30, 2007
    #4
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Michael Winter
    Replies:
    9
    Views:
    639
    Michael Winter
    Sep 24, 2003
  2. heted7
    Replies:
    33
    Views:
    1,066
    Chris Dearlove
    May 12, 2005
  3. Replies:
    7
    Views:
    388
    Richard
    Aug 28, 2006
  4. John Goche
    Replies:
    10
    Views:
    785
    Marcus Kwok
    Dec 8, 2006
  5. Replies:
    2
    Views:
    388
Loading...

Share This Page