Several base classes with identical virtual functions

[Juha Nieminen]

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);
}

 

[Victor Bazarov]

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

 

[Juha Nieminen]

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?

 

[Marcus Kwok]

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:rint'
or the 'print' in base 'Second:rint'
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.