11

我有一个类（'TestC'），它派生自另外两个类（'TestA' 和'TestB'），它们都有一个具有相同签名的虚函数。

为了使该功能可以通过“TestC”访问，我必须告诉它要使用哪个版本。如果我明确覆盖“TestC”中的函数并调用我想要的版本，则此方法有效：

#include <iostream>

class TestA
{
public:
    virtual void test() {std::cout<<"a";}
};

class TestB
{
public:
    virtual void test() {std::cout<<"b";}
};

class TestC
    : public TestA,public TestB
{
public:
    void test() {TestB::test();}
};

int main(int argc,char *argv[])
{
    TestC c;
    TestA *a = static_cast<TestA*>(&c);
    a->test();
    c.test();
    for(;;);
    return EXIT_SUCCESS;
}

输出：“bb”

这就是预期的结果。但是，我注意到如果我使用 'using' 关键字，而不是显式地覆盖函数，我会得到一些意想不到的行为：

class TestC
    : public TestA,public TestB
{
public:
    using TestB::test;
};

（其他都一样）

输出：“ab”

谁可以给我解释一下这个？看起来“测试”突然不再是虚拟的了？有没有办法做到这一点，而无需显式覆盖函数？（类似于“使用覆盖”）

4

2 回答 2

10

使用using，您不需要定义TestC::test()，而是告诉它TestB::test()是可见的（因此隐藏TestA::test()了它c.test()不会模棱两可）。

于 2016-06-03T09:57:49.513 回答
4

using 声明永远不会覆盖虚函数。但是，它可以消除多重继承的歧义。在示例中a->test()调用：

  1. 覆盖 TestC（调用 TestB::f）
  2. TestB 的覆盖（TestC 没有覆盖）

以下（菱形）虚拟继承中的 using 声明不提供所需的最终覆盖：

struct Base {
    virtual void f();
};
struct A : virtual Base {
    virtual void f() override {}
};
struct B : virtual Base {
    virtual void f() override {}
};

struct Derived : A, B {
    // error: no unique final overrider for ‘virtual void Base::f()’ in ‘Derived’
    using A::f;
};

更多示例：

#include <iostream>

// Single Inheritance
// ==================

namespace Single {

struct A {
    virtual void f() { std::cout<<"A\n"; }
};
struct AA : A {
    virtual void f() override { std::cout<<"AA\n"; }
};

struct Derived : AA {
    // Has no impact if not called explicitly
    using A::f;
};

} // namspace


// Multiple Inheritance
// ====================

namespace Multiple {

struct A {
    virtual void f() { std::cout<<"A\n"; }
};
struct AA : A {
    virtual void f() override { std::cout<<"AA\n"; }
};
struct B {
    virtual void f() { std::cout<<"B\n"; }
};
struct BB : B {
    virtual void f() override { std::cout<<"BB\n"; }
};
struct Derived : AA, BB {
    // Disambiguate A::f (AA::f) and B::f (BB::f)
    using A::f;
};

} // namspace


// Test
// ====

int main() {
    std::cout << "Single\n";
    {
        Single::Derived d;
        d.f();          // calls AA::f
        d.Derived::f(); // calls A::f because of the using-declaration
    }

    std::cout << "Multiple\n";
    {
        Multiple::Derived d;
        d.f();          // calls AA::f
        d.Derived::f(); // calls A::f because of the using-declaration
    }
}

注意：我在标准草案 N4296 中没有找到任何结论性的解释。

于 2016-06-03T21:05:26.940 回答