C++0x 中的最终虚拟函数

Question

读到您可以在 C++0x 中拥有 最终虚拟函数 我是有点困惑。与一开始就省略两个修饰符有什么区别？

Answer 1

区别在于不是使用它的基础，而是派生的。

class Base {
    virtual void foo() = 0;
};
class Derived : Base {
    void foo() {} 
    // Still virtual because it's virtual in base- no way to "un-virtual" it

    virtual void foo() final {} 
    // Now un-overridable.
};

不要将其视为防止覆盖，而是防止“更多”覆盖。

Answer 2

当我第一次在 C++ 中使用 final 关键字和 virtual 时，我也想知道同样的事情：

如果声明一个方法virtual使其可继承和可重写，并声明一个方法 最终 防止该方法被重写，声明一个方法两者不会形成矛盾吗？

我认为这个问题当前接受的答案很好，但我想根据我的情况进一步构建它发现调查这个。

考虑下面的类：

class A {
    public:
        void hide_me();
        virtual void override_me();
        virtual void cant_override_me() final;
};

要认识到的重要一点是这三个方法声明都是不同的并且意味着不同的东西。

第一个：

    void hide_me();

是非虚拟的，因此根据定义，不能被覆盖。

第三个：

    virtual void cant_override_me() final;

被声明为final，因此根据定义也不能被覆盖。

区别在于，由于 hide_me 是非虚拟的，因此覆盖它不适用，而您可以将 cant_override_me 视为符合条件 em> 被覆盖（因为它是虚拟）但是它也具有覆盖禁用，因为final 修饰符。换句话说，重写不适用于未声明为 virtual 的方法，但它确实适用于 virtual 方法，只是如果它们也是 virtual 方法，则无法重写它们声明最终。

现在考虑一个子类：

class B: public A {
    public:
        void hide_me(); // this hide's A's definition of "hide_me()"; this is not overriding.
        void override_me(); // implicit "virtual"
        //void cant_override_me(); // implicit "virtual"; compilation fails
};

您可以为类B重新定义hide_me()，但这只是重载或隐藏，因此是函数名称。 B 仍然可以通过 A::hide_me() 访问 A 的 hide_me 方法，但其他人已经对声明为 B 的 B 的引用，即：

B *my_b = new B();

必须通过以下方式访问 A 现在隐藏的 hide_me 定义my_b->A::hide_me()。

您不能在B 中提供cant_override_me() 的重新定义。

作为一个完整的示例，这里对程序进行了轻微的重新定义，以帮助举例说明发生的情况：

#include <cstdio>    
class A {
    public:
        inline void hide_me() {
            printf("a hide_me\n");
        }
        virtual void override_me();
        virtual void cant_override_me() final;
};

class B: public A {
    public:
        inline void hide_me() {
            printf("b hide_me\n");
        }
        void override_me();
        inline void foo() {
            A::hide_me();
        }
        // can't override cant_override_me
};

void A::override_me() {
    printf("a override_me\n");
}

void A::cant_override_me() {
    printf("a cant_override_me\n");
}

void B::override_me() {
    printf("b override_me\n");
}

int main (int argc, char *argv[]) {
    A *a = new A();
    A *ab = new B();
    B *b = new B();

    a->hide_me();
    ab->hide_me();
    b->hide_me();
    b->A::hide_me();

    printf("---\n");

    a->override_me();
    ab->override_me();
    b->override_me();
    b->A::override_me();
}

程序输出

a hide_me
a hide_me
b hide_me
a hide_me
---
a override_me
b override_me
b override_me
a override_me