Re: Multiple Inheritance ambiguity but not really?

From:

Nick Overdijk <nick@dotsimplicity.net>

Newsgroups:

comp.lang.c++

Date:

Sat, 11 Apr 2009 00:54:20 +0200

Message-ID:

<49dfce1d$0$67814$dbd4d001@news.wanadoo.nl>

Nick Overdijk wrote:

With this code:

#include <iostream>
using namespace std;

class car {
public:
    car (float speed) :
            speed(speed) {}

    car () :
            speed(0) {}

    void cruise(float speed) {
        this->speed = speed;
        cout << "New speed: " << getSpeed() << endl;
    }

    void brake(float power) {
        this->speed -= power*power/4;
    }

    float getSpeed() {
        return speed;
    }

private:
    float speed;
};

class racer : public car {
public:
    void boost(float power) {
        cout << "BOOST! ";
        cruise(getSpeed() + power*power/3);
    }
};

class tank : public car {
public:
    bool shoot(float aimTime) {
        cout << "Shot ";
        if (aimTime > 5.0) {
            cout << "hits!" << endl;
            return true; //hit!
        } else {
            cout << "misses!" << endl;
            return false; //miss!
        }
    }

};

class racetank : public racer, public tank {
public:
    bool boostShoot(float power, float aimTime) {
        boost(power*2);
        return shoot(aimTime*2);
    }
};

int main() {
    racetank mycar;
    mycar.car::cruise(50);
    mycar.boost(20);
    mycar.car::brake(5);
    mycar.boostShoot(35, 1.4);

    return 0;
}

MinGW's GCC gives me this error, twice:
error: `car' is an ambiguous base of `racetank'

How come the compiler still complains about ambiguity?

It knows the function is not overloaded (?)
It knows the function is not virtual.

Can't the compiler be sure that when I call the function like that, it's
the same function?

I know the solution to this is to use virtual inheritance, but I was
wondering why this happens.

Thanks in advance,

Replying to myself yeey.

Let a class in memory be resembled by:

[classname]

Class inheritance in memory looks like this, according to wikipedia.

class a;
class b : a;

class a looks like this: [a]

b looks like this: [a][b]

So if we'd have a class base and c, we can create a diamond inheritance:

class base;
class a : base;
class b : base;
class c : a, b;

Their memory-pictures are like this:

base: [base]
a: [base][a]
b: [base][b]
c: [base][a][base][b][c]

c, more specific, looks like this: [a::base][a][b::base][b][c]

So, naturally, a::base and b::base data members can differ, but
a::base::func() must be the same as b::base::func() given that a and b
don't overload and func() is not virtual right? How else can they be
different?