C++11 C+中的最终虚函数+；0x

阅读C++0x中的内容时，我有点困惑。首先省略这两个修饰符有什么区别？

不同之处在于使用它的不是基，而是派生的

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.
};

---

认为它不是防止重写，而是防止“重写”。

< P>当我第一次在C++中使用<代码>最终< /Cord>>关键字> <代码>虚拟<代码>时，我想知道同样的事情：

如果声明一个方法使它可以继承和重写，并且声明一个方法可以防止该方法被重写，那么声明一个方法不就形成了矛盾吗

我认为目前这个问题的答案是好的，但我想根据我在这方面的发现，在这个基础上再进一步

考虑以下类别：

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;

被声明为最终的，因此也不能被定义覆盖

不同之处在于，由于

hide\u me

是非虚拟的，因此重写它是不可行的，而您可以将

cant\u override\u me

视为有资格被重写（因为它是

virtual

，）但它也由于

final

修饰符而禁用了重写。换句话说，重写不适用于未声明的

virtual

方法，但它适用于

virtual

方法，如果它们也声明为

final

，则不能重写它们

现在考虑子类：

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();

必须通过

my\u b->A:：hide\u me（）

访问

A

现在隐藏的

hide\u me

定义

您不能在

B

中提供对

cant\u override\u 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();
}

---

在该示例中考虑，如果<代码> BASE<代码>继承了另一个声明初始基础<代码> f>代码>方法的类。谢谢！我还不清楚，虚拟机是否会贯穿整个层次结构。

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