C++从多个具有相同虚函数名的基类继承

Question

我试过这段代码：

class A
{
    virtual void foo() = 0;
};

class B
{
    virtual void foo() = 0;
};

class C : public A, public B
{
    //virtual void A::foo(){}
    //virtual void B::foo(){}

    virtual void A::foo();
    virtual void B::foo();
};

void C::A::foo(){}
void C::B::foo(){}

int main()
{
    C c;
    return 0;
}

使用注释部分是可以的，但是当我尝试在类声明之外编写定义时，编译器会报错。 我正在使用 MSVC11 编译器，有人知道如何编写吗？ 我需要将代码移动到 cpp 文件中。

谢谢~~

Answer 1

函数根据名称和参数类型覆盖基类的虚函数（见下文）。因此，您的类C 有两个 虚函数foo，一个继承自A 和B。但是函数void C::foo() 覆盖了both：

[class.virtual]/2

如果在类Base和类Derived中声明了一个虚拟成员函数vf，则直接或间接派生自Base，则一个同名的成员函数vf， parameter-type-list、cv-qualification 和 ref-qualifier（或不存在相同）作为 Base::vf 被声明，然后 Derived::vf 也是虚拟的（无论是否如此声明）并且它 覆盖 Base::vf.

正如我在 cmets 中所述，[dcl.meaning]/1 禁止在（成员）函数的声明中使用 qualified-id：

当 declarator-id 被限定时，该声明应引用该限定符所引用的类或命名空间的先前声明的成员 [...]"

因此，任何virtual void X::foo(); 作为C 中的声明都是非法的。

代码

class C : public A, public B
{
    virtual void foo();
};

是 AFAIK 覆盖foo 的唯一方法，它将同时覆盖A::foo 和B::foo。除了引入另一层继承之外，没有办法为 A::foo 和 B::foo 设置两个不同的覆盖行为：

#include <iostream>

struct A
{
    virtual void foo() = 0;
};

struct B
{
    virtual void foo() = 0;
};

struct CA : A
{
    virtual void foo() { std::cout << "A" << std::endl; }
};

struct CB : B
{
    virtual void foo() { std::cout << "B" << std::endl; }
};

struct C : CA, CB {};

int main() {
    C c;
    //c.foo();  // ambiguous

    A& a = c;
    a.foo();

    B& b = c;
    b.foo();
}

Answer 2

你只有一个虚函数foo：

class A {
    virtual void foo() = 0;
};

class B {
    virtual void foo() = 0;
};

class C : public A, public B {
    virtual void foo();

};

void C::foo(){}
void C::A::foo(){}
void C::B::foo(){};

int main() {
    C c;
    return 0;
}

Answer 3

我遇到了同样的问题，不小心打开了第二个线程。对此感到抱歉。对我有用的一种方法是在没有多重继承的情况下解决它。

#include <stdio.h>

class A
{
public:
    virtual void foo(void) = 0;
};

class B
{
public:
    virtual void foo(void) = 0;
};


class C
{
    class IA: public A
    {
        virtual void foo(void)
        {
            printf("IA::foo()\r\n");
        }
    };
    class IB: public B
    {
        virtual void foo(void)
        {
            printf("IB::foo()\r\n");
        }
    };

    IA m_A;
    IB m_B;
public:
    A* GetA(void)
    {
        return(&m_A);
    }

    B* GetB(void)
    {
        return(&m_B);
    }
};

诀窍是将派生自接口（A 和 B）的类定义为本地类（IA 和 IB），而不是使用多重继承。此外，如果需要，这种方法还打开了每个接口的多个实现的选项，而这在使用多重继承时是不可能的。 本地类 IA 和 IB 可以很容易地访问类 C，因此接口 IA 和 IB 的实现可以共享数据。

各接口的访问方式如下：

main()
{
    C test;
    test.GetA()->foo();
    test.GetB()->foo();
}

...关于 foo 方法不再有歧义。

Answer 4

您可以使用不同的函数参数来解决这种歧义。

在现实世界的代码中，这样的虚函数会做一些事情，所以它们通常已经有：

1. A 和 B 中的不同参数，或
2. 为了解决这个继承问题，你可以将A和B中不同的返回值变成[out]参数；否则
3. 您需要添加一些标签参数，优化器会丢弃这些参数。

（在我自己的代码中，我通常发现自己在情况（1）中，有时在（2）中，到目前为止从未在（3）中。）

您的示例是案例 (3)，如下所示：

class A
{
public:
    struct tag_a { };
    virtual void foo(tag_a) = 0;
};

class B
{
public:
    struct tag_b { };
    virtual void foo(tag_b) = 0;
};

class C : public A, public B
{
    void foo(tag_a) override;
    void foo(tag_b) override;
};

Answer 5

比阿迪戈斯汀溶液略有改善：

#include <iostream>

struct A {
    virtual void foo() = 0;
};

struct B {
    virtual void foo() = 0;
};

template <class T> struct Tagger : T {
    struct tag {};
    void foo() final { foo({}); }
    virtual void foo(tag) = 0;
};

using A2 = Tagger<A>;
using B2 = Tagger<B>;

struct C : public A2, public B2 {
    void foo(A2::tag) override { std::cout << "A" << std::endl; }
    void foo(B2::tag) override { std::cout << "B" << std::endl; }
};

int main() {
    C c;
    A* pa = &c;
    B* pb = &c;
    pa->foo(); // A
    pb->foo(); // B
    return 0;
}

假设基类A和B已经给定且不能修改。