Distinct implementations for pure virtual functions with same name

Question

Possible Duplicate:
Inherit interfaces which share a method name

I have two base classes I1 and I2 with pure virtual functions void R() = 0;. I want the derived class IImpl to inherit from I1 and I2 and to have distinct implementations for I1::R() and I2::R().

The code below compiles and works in MS VS 2005 and 2010. I compile with Language Extension disabled and on warning level 4. There are no warnings and no errors.

I tried the same code in gcc 4.2. It does not compile. GCC reports an error:

error: cannot define member function 'I1::R' within 'IImpl'

My questions are:

1. Why that code works in MS VS and why it does not work in gcc?
2. Is the code a standard C++?
3. What is the correct way to implement it, so it is a standard C++ and compiles on VS and gcc?

Thanks!

#include <stdio.h>

class I1
{
public:
    virtual void R() = 0;
    virtual ~I1(){}
};

class I2
{
public:
    virtual void R() = 0;
    virtual ~I2(){}
};

class IImpl: public I1, public I2
{
public:

    virtual void I1::R()
    {
        printf("I1::R()\r\n");
    }

    virtual void I2::R()
    {
        printf("I2::R()\r\n");
    }
};

int main(int argc, char* argv[])
{
    IImpl impl;

    I1 *p1 = &impl;
    I2 *p2 = &impl;

    p1->R();
    p2->R();

    return 0;
}

Answer 1

This code is non-standard, according to 8.3/1

A declarator-id shall not be qualified except for the definition of a member function (9.3) or static data member (9.4) outside of its class,...

so you can't qualify member function names when declaring/defining them inside the class. That's why it isn't compiled by gcc.

MSVC seems to have a non-standard extension allowing such code. I guess it was done for Managed Extensions for C++, that's exactly how explicit interface implementations were done there and although it was deprecated long ago seems that syntax is still supported.

A correct way to implent it is decribed at the link provided by Björn Pollex.

Answer 2

You only get to implement void R() once in IImpl.

Answer 3

IImpl impl;

I1 *p1 = &impl;
I2 *p2 = &impl;

p1->R();
p2->R();

This doesn't make sense to me. R() is a virtual method, so it doesn't matter whether you call it on I1* or I2* as long as the real object is IImpl. Besides, IImpl has two similar R(), which one do you expect to be called for impl.R()? I'm not familiar with the standard enough to quote it, but I'm sure what you're doing is an error. Correct me if I'm wrong.

Answer 4

@Violet Giraffe

This is an answer to Violet Giraffe's answer. It also clears some misunderstandings of late binding and MI, which is more flexible than Java inheritance.

so it doesn't matter whether you call it on I1* or I2* as long as the real object is IImpl.

// interfaces
class I1
{
public:
    virtual void f () = 0;
};

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

// concrete implementations
class C1 : public I1
{
public:
    virtual void f () { cout << "C1::f()\n"; }
};

class C2 : public I2
{
public:
    virtual void f () { cout << "C2::f()\n"; }
};

// putting both together
class D : public C1, public C2
{
};

template <class I>
void f (I &i) {
    i.f(); // virtual call to I::f()
}

int main() {
    D d;
    f<I1> (d); // virtual call to I1::f(): prints C1::f()
    f<I2> (d); // virtual call to I2::f(): prints C2::f()
}

A call to a member function is always statically bound to one function declaration (here I1::f() and I2::f()). At runtime, the function called (by the process called "late binding") is the most derived overrider (technical term is "final") of this virtual function (here C1::f() and C2::f()).

In any class, there must be at most one final overrider of every pure virtual function. In a non-abstract class, there must be exactly one final overrider of every virtual function.

Now you see that I1::f() and I2::f() are different functions, and that they are quite unrelated; but both have the same unqualified name and same parameters, so they cannot be distinguished by overloading. And if the qualified name is used (d.I1::f() and d.I2::f()) the call would bind to the correct declaration, but virtual-ness would also be inhibited (in this case a definition of the pure virtual function must exist and will be called). So the only way to call either function is what I have done here: first make a lvalue of type I1/I2, only then make an unqualified call .f().

Side note: This kind of distinct overriding is impossible in Java, because MI is strictly limited, and overriding follows different rules.

Besides, IImpl has two similar R(), which one do you expect to be called for impl.R()?

Which f() do you expect to be called in d.f()?