Re: Ambiguous in MI

From:

James Kanze <james.kanze@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Mon, 2 Nov 2009 01:33:18 -0800 (PST)

Message-ID:

<a5e59eed-a846-4735-853a-b2e8cc1b469a@m16g2000yqc.googlegroups.com>

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