c++ - 为什么派生类重写了基类的方法，还要调用基类的方法？

Question

考虑以下程序:

class Base {
public:
    virtual void foo() const {
        cout << "Base::foo()" << endl;
    }
};

class Derived : public Base {
public:
    virtual void foo() {
        cout << "Derived::foo()" << endl;
    }
};

void func(Base& obj) {
    obj.foo();
}

void main() {
    Derived d;
    func(d); // Base::foo() is printed 
}

如果我从 Base 类 foo 方法中删除 const，则 Derived::foo() 是叫。我似乎无法理解这种行为。

1) 这种行为的原因是什么？

2) 这是编译时还是运行时决定的？

谢谢

Answer 1

在派生类中，函数签名是这样的:

virtual void foo(); //Derived::foo

其中没有提到 const。它是一个非常量成员函数，而 Base::foo 是一个const 成员函数。它们是两个不同的函数，因为 const 是函数签名的一部分。

virtual void foo() const; //Base::foo 

派生类不会覆盖此函数，而是添加另一个函数。

所以修复是这样的:

class Derived : public Base {
public:
    virtual void foo() const {
        cout << "Derived::foo()" << endl;
    }
};

因为 const 是函数签名的一部分。因此，当您打算覆盖 base 的 foo 时，必须提及它。

---

@davka 的提问:

so why the const version is selected over the non-const? Is there any rule or it just happened to be the first option?

因为obj的static类型是Base，函数名是根据对象的静态类型解析的。 Base 甚至没有非常量 版本。所以不存在被选中或被拒绝的问题。它不存在于 Base 中。

void func(Base& obj) {
    obj.foo();  //calls Base::foo
}

但是，如果将上面的代码改成下面这样:

void func(Derived & obj) {
    obj.foo();  //calls Derived:foo
}

现在将选择非常量版本，因为 Base::foo 隐藏在 Derived 类中。

---

由于 Derived::foo 隐藏了 Base::foo，因此您不能使用 Derived 的实例调用后者。

现在，让我们取消隐藏 Base::foo 并做一些更多的实验。

class Derived : public Base {
public:
    using Base::foo;         //<----------------this unhides Base::foo
    virtual void foo() {
        cout << "Derived::foo()" << endl;
    }
};

现在在 Derived 中，两个函数(const 和非 const 版本)都可用，并且未隐藏。现在有几个有趣的问题。

由于现在 Derived 的两个函数都未隐藏，下面的每个函数将调用哪个函数？

void f(Derived& obj) {
    obj.foo(); //Which function? Base::foo or Derived::foo?
}
void g(const Derived & obj) {
    obj.foo(); //Which function? Base::foo or Derived::foo?
}

第一个将调用非 const 版本的 Derived::foo，第二个将调用 const 版本的 Base::foo。原因很简单，对于 const 对象，只能 const 函数可以被调用，但是对于非 const 对象，两者都可以被调用，但是选择非 const 版本如果它可用。

参见在线演示:http://www.ideone.com/955aY