Ambiguous in MI

[tas]

class B{
public:
virtual void fun() = 0;
.......
};
class C{
public:
void fun();
};
class A: public B, private C {

};

void A::fun(){
........
}

MSVC 6.0 : " 'A::fun()' is ambiquous could be the 'fun' in base B of
class A or the 'fun' in base C of class A."

But when i wrote "public:void fun();" in class A all was good.
Why is this happening? And how i can redefine 'C::fun()' in class A?

 

[Alf P. Steinbach]

* tas:

class B{
public:
virtual void fun() = 0;
......
};
class C{
public:
void fun();
};
class A: public B, private C {

};

void A::fun(){
.......
}

MSVC 6.0 : " 'A::fun()' is ambiquous could be the 'fun' in base B of
class A or the 'fun' in base C of class A."

But when i wrote "public:void fun();" in class A all was good.

I take it this means that when you provided a declaration in class A then the
compiler finally accepted your code.

Why is this happening?

C++ requires declarations.

And how i can redefine 'C::fun()' in class A?

You can redefine it and that is what you've done above, but that's surely not
what you mean. You probably mean how you can override it. To override it it
needs to be virtual in C.


Cheers & hth.,

- Alf

PS: Who or what tricked you into using a anachronism like MSVC 6.0?

 

[tas]

Cheers & hth.,

- Alf

PS: Who or what tricked you into using a anachronism like MSVC 6.0?

my teacher for the OOP. in our class set MSVC 6.0...

 

[tas]

thanks for all.
I finally realized.

 

[James Kanze]

* tas:

I take it this means that when you provided a declaration in
class A then the compiler finally accepted your code.

C++ requires declarations.

And definitions, if the declared thing is "potentially used"
(and any virtual function is potentially used if the class is
instantiated).

You can redefine it and that is what you've done above, but
that's surely not what you mean. You probably mean how you can
override it. To override it it needs to be virtual in C.

I suspect (but I'm really just guessing) that what he's
expecting is the behavior of Java: that C::fun() will provide
the implementation of B::fun(), just because the function
happens to accidentally have the same name in two different,
unrelated classes. C++ doesn't have this defect in the
language; you have to explicitly tell the compiler that the
implementation in C::fun() is the one you want here, by defining
an A::fun() which calls C::fun().

 

[Pavel]

And definitions, if the declared thing is "potentially used"
(and any virtual function is potentially used if the class is
instantiated).



I suspect (but I'm really just guessing) that what he's
expecting is the behavior of Java: that C::fun() will provide
the implementation of B::fun(), just because the function
happens to accidentally have the same name in two different,
unrelated classes. C++ doesn't have this defect in the
language; you have to explicitly tell the compiler that the
implementation in C::fun() is the one you want here, by defining
an A::fun() which calls C::fun().

You are confusing me.. Care to share an example of Java code you had in
mind?

-Pavel

 

[James Kanze]

James Kanze wrote:

[...]

You are confusing me.. Care to share an example of Java code
you had in mind?

It's been a while since I've last programmed in Java, but if I
recall correctly, something like the following is perfectly good
Java:

interface I
{
void f();
}

class B
{
public void f() {}
}

class D extends B implements I
{
}

The B::f() overides the I::f(), even though the author of B has
no idea what I is or expects. Given the equivalent in C++:

class I
{
public:
virtual ~I() {}
virtual void f() = 0;
};

class B
{
public:
void f() {}
};

class D : public B, public I
{
};

, class D is still abstract, since the function B::f() does not
override I::f(). The author of D must make it explicit by
defining D::f().