Question

这是我的示例代码：

class Interface {
    public:
        virtual void foo(const Interface &interface) = 0;
};

class A : public Interface {
    public:
        void foo(const A &a) {
                // do something with another object of same type
        }
};

class B : public Interface {
    public:
        void foo(const B &b) {
        }
};

有警告：

warning: 'A::foo' hides overloaded virtual function
      [-Woverloaded-virtual]
            void foo(const A &a) {
                 ^
note: hidden overloaded virtual function 'Interface::foo'
      declared here: type mismatch at 1st parameter ('const Interface &' vs
      'const A &')
            virtual void foo(const Interface &interface) = 0;

如何处理问题？在派生类中添加using Interface::foo;是最佳解决方案吗？我认为这是一个常见问题。非常感谢！

Answer 1

void foo(const A &a)不会覆盖void foo(const Interface &interface)。虽然该语言允许协变返回类型，但据我所知，你不能有协变参数。

所以你的void foo(const A &a)隐藏了（或者最多超载）函数的基本版本。

如果您使用C ++ 11的override关键字，编译器应该更清楚地告诉您，您没有覆盖。或者，如果您尝试实例化A，那么它应该会失败并显示有关A是抽象的错误，因为它实际上没有覆盖foo。

当然，解决方案是使派生版本使用与foo完全相同的参数类型。

Answer 2

virtual函数的virtual void foo()部分表示可以在继承Interface的类中覆盖它。在class A和B中，您使用了相同的函数但更改了参数，这意味着函数将被重载。

如果您想要覆盖子类中的函数，请使用void foo(const Interface &interface)。

有关重载虚拟函数的更多详细信息，请参阅以下文章：Overloading a virtual function in a child class

Answer 3

感谢@GargAnkit发表评论，这是我的全部投入：

#include <iostream>
#include <string>

using std::cout;
using std::endl;

class Interface {
    public:
        int compare(const Interface &that) const {
            if (this->to_string() < that.to_string()) {
                return -1;
            } else if (this->to_string() == that.to_string()) {
                return 0;
            } else {
                return 1;
            }
        }

        virtual std::string to_string() const = 0;
};

class A : public Interface {
    public:
        std::string to_string() const override {
            return "A";
        }
};

class B : public Interface {
    public:
        std::string to_string() const override {
            return "B";
        }
};

int main() {
    A a;
    B b;
    cout << a.compare(b) << endl;
    cout << "ok" << endl;

    return 0;
}

Answer 4

要在基类中将某个函数替换为某个函数的替代，这两个函数必须完全匹配-相同的名称，相同的参数，相同的const / volatile限定。如果功能仅因资格不同而不同，它们将被视为完全不相关的功能，而基本功能将不被视为已覆盖。

示例：： **

class A
{
public:
virtual void fun(..)const{}
};
class B:public A
{
public:
void fun(..){} //violation
};

**

C ++＆＃34;超载虚拟警告＆＃34;实现界面时

4 个答案: