Finite virtual functions in C ++ 0x

Question

Reading that you can final virtual functions in C ++ 0x. I'm a little confused. What is the difference from the simple exclusion of both modifiers?

Answer 1

The difference arises not in the database that uses it, but in the derivative.

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

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

Think of it not as preventing overrides, but as preventing overrides of "more."

Answer 2

When I first met the use of the keyword finalin combination with virtualin C ++, I was interested in the same thing:

virtual final , ?

, , , .

:

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 ( virtual,) , - final. , , virtual, virtual, , final.

:

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

hide_me() B, , , . B A hide_me A::hide_me(), -, B, B, :

B *my_b = new B();

A hide_me my_b->A::hide_me().

cant_override_me() B.

, , , :

#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