Ambiguity issue

[George2]

Hello everyone,


I think compiler is too strict in this case. You can see, no data member, no virtual function.

I am using Visual Studio 2008. The compiler error is simply because of Diamond pattern -- duplicate base class? Actually from logical point of view, there should be no ambiguity issue.

Any ideas?

#include <iostream>
 
using namespace std;
 
class Base {
public:
    int foo() {cout << "Base" << endl;}
};
 
class Derived1: public Base
{
public:
    int foo() {cout << "Derived1" << endl;}
};
 
class Derived2: public Base
{
public:
    int foo() {cout << "Derived2" << endl;}
};
 
class Final: public Derived1, public Derived2 {
public:
    int foo() {cout << "Final" << endl;}
};
 
int main()
{
    Final f;
    Final* p = &f;
    Base* pb = p; //error C2594: 'initializing' : ambiguous conversions from 'Final *' to 'Base *'
    return 0;
}
 

thanks in advance,
George

[ashitpro]

Hello everyone,


I think compiler is too strict in this case. You can see, no data member, no virtual function.

I am using Visual Studio 2008. The compiler error is simply because of Diamond pattern -- duplicate base class? Actually from logical point of view, there should be no ambiguity issue.

Any ideas?

#include <iostream>
 
using namespace std;
 
class Base {
public:
    int foo() {cout << "Base" << endl;}
};
 
class Derived1: public Base
{
public:
    int foo() {cout << "Derived1" << endl;}
};
 
class Derived2: public Base
{
public:
    int foo() {cout << "Derived2" << endl;}
};
 
class Final: public Derived1, public Derived2 {
public:
    int foo() {cout << "Final" << endl;}
};
 
int main()
{
    Final f;
    Final* p = &f;
    Base* pb = p; //error C2594: 'initializing' : ambiguous conversions from 'Final *' to 'Base *'
    return 0;
}
 

thanks in advance,
George

Well..
This is a typical problem of multiple inheritance.
Have a look at this statement:

class Final: public Derived1, public Derived2

You are inheriting through Derived1 and Derived2.
And very imp thing is that both of them were derived from Base.
So Final class will receive two copies of Base. One from Derived1 and other from Derived2. Thus ambiguity has to happened.
When you use such type of construct don't forget to add "virtual" word in every child of a Base. Here your code must look like.

class Derived1: virtual public Base

class Derived2: virtual public Base

Note:"virtual" word may appear after "public".

[hdanw]

This was taken from the MSDN .net 2003 documentation

'operator' : ambiguous conversions from 'type1' to 'type2'
No conversion from type1 to type2 was more direct than any other. One possible solution is to define or specify an explicit conversion.
The following sample generates C2594:
// C2594.cpp
// compile with: /c
struct A{};
struct I1 : A {};
struct I2 : A {};
struct D : I1, I2 {};
A *f (D *p) {
return (A*) (p); // C2594
// try the following line instead
// return reinterpret_cast<A*> (p);
}

Does this make since to you?

Just what are you trying to do anyway. I bet you could save some time asking different question rather than trial and error. But then again that is how I learned.

keep in mind that there are not multiple entries in the function table for the object Final, and for the function foo(). There is only one.

the object pb points to a different function table, and will use that instance of foo();

change some code to this

Base* pb = reinterpret_cast<Base*> (p);
 
f.foo();
 
p->foo();
 
pb pb->foo();
 
 

you should see :

Final
Final
Base

Also you need to drop the "int" or add a return value to your foo functions.

Now change base class to

class Base 
{
    public:
 
    virtual int foo() {cout << "Base" << endl; return 0;}
 
};
 
 

Now look at what you get.

The base class does point to all instances of foo();

So the Base object pb calls the function foo stored in the function table for the object 'f' .

you should see:

Final
Final
Final

If you'd like to see some powerfull objects in cpp I have loads of code you could look at.

Dan -

[hdanw]

Well..
You are inheriting through Derived1 and Derived2.
And very imp thing is that both of them were derived from Base.
So Final class will receive two copies of Base. One from Derived1 and other from Derived2. .

Thats not true;

Both Derived1 and Derived2 have foo that is true, but once he declared a new instance of the function foo(), both of those methods are overridden with the local definition.

Take out the local definition and see what happens.

Dan -

[ashitpro]

Thats not true;

Both Derived1 and Derived2 have foo that is true, but once he declared a new instance of the function foo(), both of those methods are overridden with the local definition.

Take out the local definition and see what happens.

Dan -

Thanks for reply Dan.
Have a look at this link.

http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.vacpp7a.doc/language/ref/clrc14cplr135.htm

I think It has nothing to do with foo() function.
The problem is here because of Final receives two copies of Base.
More precisely, we are not even calling any functions.
What I thought was the concept of Virtual Base Class.
Please..explain this thing more deeply.

[hdanw]

Thanks for reply Dan.
Have a look at this link.

http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.vacpp7a.doc/language/ref/clrc14cplr135.htm

I think It has nothing to do with foo() function.
The problem is here because of Final receives two copies of Base.
More precisely, we are not even calling any functions.
What I thought was the concept of Virtual Base Class.
Please..explain this thing more deeply.

I wrote a number of classess I though were great they all interacted the same way, kept things simple. well then i tried to derive a class that came from 2 of the previous classes, and the same situation occurs where the interface is the same from each.

Something I definately avoid now.

But what is happening is at compiler time.

Since the two derived classes versions of foo are overridden, they dont exist in Final. and thus not the cuase of "THIS" problem.

But keep programming that way and sooner or later your world will crash.

The ambiguity from

Base dp = (p);

is becuase the compiler has no directive to decide whether to use the foo from final, or the foo from Base.

the object p at runtime has a function table associated with it that points to the foo that was assigned at declaration :

Final * p = ...

thus p->foo points to Final.foo

and the base object pb treats the assigned pointer as if it were a pointer to Base, so naturally the compiler assumes that

pb->foo will point to Base->foo, and it does.

So now the compiler has a pointer to a Base:foo that is actually declared as a deferent function Final:foo.

We have a ... but we are calling it a ...,

so the compiler responds with, what the *ell are you doing, do you want me to use ... or ...

We can shut the compiler up by telling to act like the object p is a pointer to Base and not Final. And thus the compiler links to the function table associated with Base, or Base:foo to be exact.

When we declare foo as a virtual function, this tells the compiler that there will be new version of foo coming, and that one should always take precedent.

So The compiler uses the function table associated with the pointer p
and when invoked calls Final:foo;

There are a lot of tricky situations when dealing with multiple inheritance and the combination of virtual and hidden functions.
Hidden functions don't always operate the way you'd like them to.

For example calling a hidden function from within a virtual function sometimes calls the function that you though was hidden. And not the function doing the hiding.

Using virtual keyword is better to garantee that the overloaded function is not being called.

[hdanw]

if we comment out the overriding foo in final like this

class Final:public Derived1, public Derived2 {
 
public:
 
// int foo() {cout << "Final" << endl;return 0;}
 
};
 
 

then we get the compiler error

c:\delme\tempme\tempme.cpp(36): error C2385: ambiguous access of 'foo' in 'Final'


becuase, very straight forward, the compiler does not know whether to use Derived1:foo or Derived2:foo

And this will not compile no matter what you do.

A lot of newbies try to derive classes, upon classes.
They need to learn to move "base" classes to the members section.

They need to be able to answer:

What is an aggregate? and when do I use one?

The answer is a collection, like a box full. Not a growth like a tree.

Use them more often than not.

For example you might say that a car has an engine, and a gas can

class car
{
public:
engine enginetype;
fueltank reserve;
}
 

versus

class car:public engine, public fueltank
{
}
 

Which is the aggregate?

you might have a a function called start in engine definition so that the first would be

car:engine:start(), while the second is car:start(); Which sounds better.

But believe me, it is better to use the first example, and then define a function start that acts on the member engine,
car:start(); // that sound good

The general rule of thumb is if its not ever going to act like a ... then it should not be derived from ...

for example you cant use the car like a gas can, so

class car:public fueltank{}

doesn't make much since

however if you want to modify a car class and the sub class does everything the original did, and can be used just like the base class car then it makes since

class ferrari: public car{}

Thats oop in a nut shell.

Happy coding.

Dan -

[weaknessforcats]

Base* pb = p; //error C2594: 'initializing' : ambiguous conversions from 'Final *' to 'Base *'

In this case the compiler can't tell which Base* to conver to: The one from Derived1 or the one from Derived2. I'm sure tou are aware that there are two base objects in your final object.

This is exactly the design of the IUknown of COM. But Microsoft does not do stuff like this. Instead, they developed a QueryInterface() that works around this.

[George2]

Hi Dan,


Can you show your completed code for how do you get the output,

--------------------
Final
Final
Final
--------------------

I can not understand how you make the pointer to Base pointing to the function table of Final?

So the Base object pb calls the function foo stored in the function table for the object 'f' .

you should see:

Final
Final
Final

If you'd like to see some powerfull objects in cpp I have loads of code you could look at.

Dan -

regards,
George

[George2]

Hi hdanw,


Great reply! But I am not 100 sure about your samples.

In your below description, the code,

Base dp = (p);

should not compile not because of ambiguity issue, but syntax issue (left side object type, right side pointer type)

"We can shut the compiler up " -- what your compiler errors?

Again, it is appreciated if you could post your code and compiler error messages here to make your points more clear.

The ambiguity from

Base dp = (p);

is becuase the compiler has no directive to decide whether to use the foo from final, or the foo from Base.

the object p at runtime has a function table associated with it that points to the foo that was assigned at declaration :

Final * p = ...

thus p->foo points to Final.foo

and the base object pb treats the assigned pointer as if it were a pointer to Base, so naturally the compiler assumes that

pb->foo will point to Base->foo, and it does.

So now the compiler has a pointer to a Base:foo that is actually declared as a deferent function Final:foo.

We have a ... but we are calling it a ...,

so the compiler responds with, what the *ell are you doing, do you want me to use ... or ...

We can shut the compiler up by telling to act like the object p is a pointer to Base and not Final. And thus the compiler links to the function table associated with Base, or Base:foo to be exact.

regards,
George

[hdanw]

You are correct, I thought I included that.

The code should read

Base* pb  = reinterpret_cast<Base*> (p);
 

This resolves the initial problem. But again as soon as you comment out the foo definition in final, you get the compiler error that ashitpro was indicating.

To get the
Final
Final
Final

we declare the base class foo as virtual:

class Base {
public:
    virtual int foo() {cout << "Base" << endl; return 0;}
};
 

AS per your request the intire program is here:

#include <iostream>
#include <stdafx.h> 
 
using namespace std;
 
class Base {
public:
    virtual int foo() {cout << "Base" << endl; return 0;}
};
 
class Derived1: public Base
{
public:
    int foo() {cout << "Derived1" << endl;return 0;}
};
 
class Derived2: public Base
{
public:
     int foo() {cout << "Derived2" << endl;return 0;}
};
 
class Final: public Derived1, public Derived2 {
public:
  int foo() {cout << "Final" << endl;return 0;}
};
 
int main()
{
    Final f;
    Final* p = &f;
    //Base* pb = (p); //error C2594: 'initializing' : ambiguous conversions from 'Final *' to 'Base *'
    Base* pb = reinterpret_cast<Base*> (p);
    f.foo();
    p->foo();
    pb->foo();
 
    return 0;
}
 

Happy Coding

[hdanw]

You need to understand the at run time a pointer is just that, but at compile time the pointer is 1- a pointer with size and location, and 2 - pointer to Something.

The type information exists so that the compiler can do a number of things that they normally wouldn't.

For example.

 
struct somestruct
{
    int x, y, z;
    float a, b;
}
somestruct mytable[64];
 
(...)
 
somestruct * ptable = mytable;
 
ptable++;
 

In the above code, the compiler knows that ptable is a pointer, and to a somestruct object. The ++ on the pointer instructs the compiler to calculate the offset to the next intry in mytable.

it is equivalent to mytable[1];

As a result a pointer to apples cannot be treated the same as a pointer to oranges.

Happy Coding.

Dan -

[George2]

Hi hdanw,


Why in your below code,

pb->foo();

will output Final other than output Base? I have tested that the output is Final.

My question is
1. pb points Final instance, and the foo in Final is not virtual method;
2. so the output should be invoking the foo based on the type of pointer (which is Base), then the output should be Base?


regards,
George

You are correct, I thought I included that.

The code should read

Base* pb  = reinterpret_cast<Base*> (p);
 

This resolves the initial problem. But again as soon as you comment out the foo definition in final, you get the compiler error that ashitpro was indicating.

To get the
Final
Final
Final

we declare the base class foo as virtual:

class Base {
public:
    virtual int foo() {cout << "Base" << endl; return 0;}
};
 

AS per your request the intire program is here:

#include <iostream>
#include <stdafx.h> 
 
using namespace std;
 
class Base {
public:
    virtual int foo() {cout << "Base" << endl; return 0;}
};
 
class Derived1: public Base
{
public:
    int foo() {cout << "Derived1" << endl;return 0;}
};
 
class Derived2: public Base
{
public:
     int foo() {cout << "Derived2" << endl;return 0;}
};
 
class Final: public Derived1, public Derived2 {
public:
  int foo() {cout << "Final" << endl;return 0;}
};
 
int main()
{
    Final f;
    Final* p = &f;
    //Base* pb = (p); //error C2594: 'initializing' : ambiguous conversions from 'Final *' to 'Base *'
    Base* pb = reinterpret_cast<Base*> (p);
    f.foo();
    p->foo();
    pb->foo();
 
    return 0;
}
 

Happy Coding

[hdanw]

George,

Go back and read everything I posted.

There is a very good c++ explination, and the answer to your question can be found there.

Good Luck,

Dan -