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...

[Contantine]

> But when i wrote "public:void fun();" in class A all was good. Why is
> this happening?

class A must override B::fun() since B::fun() is declared pure virtual.

If B::fun() was not pure virtual, and A did not declare public:void fun
(), then your compiler's error message would then be the most accurate
description of the resulting situation: there would be no way to
determine if A::fun() referred to the fun() inherited from B or the one
inherited from C.

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

As Alf pointed out, if you declare C::fun() to be virtual, then A::fun()
will override it. Bear in mind that even then, only members and friends
of A will be able to access A through a C reference.

Constantine

[tas]

thanks for all.
I finally realized.

[James Kanze]

On Oct 24, 2:28 pm, "Alf P. Steinbach" <al...@start.no> wrote:
> * 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 definitions, if the declared thing is "potentially used"
(and any virtual function is potentially used if the class is
instantiated).

> > 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.

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().

--
James Kanze

[Pavel]

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

-Pavel

>
> --
> James Kanze

[James Kanze]

On Oct 31, 5:36 pm, Pavel
<pauldontspamt...@removeyourself.dontspam.yahoo> wrote:
> James Kanze wrote:

[...]

> > 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?

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().

--
James Kanze