C++11 中 final 和 override 从入门到精通

一、引言

在 C++ 编程的世界里，继承和多态是面向对象编程的核心特性。通过继承，我们可以创建新的类，复用现有类的代码；通过多态，我们可以以统一的方式处理不同类型的对象。然而，在实际开发中，我们可能会遇到一些问题，比如不小心重写了基类的虚函数，或者希望某个类不能被继承，某个虚函数不能被重写。为了解决这些问题，C++11 引入了两个重要的关键字：final 和 override。这两个关键字的引入，使得我们在处理类的继承和虚函数的重写时更加灵活和安全。

二、final 关键字

2.1 final 关键字的基本概念

final 关键字用于限制类的继承和虚函数的重写。当 final 用于类时，表示该类不能被继承；当 final 用于虚函数时，表示该虚函数不能在派生类中被重写。

2.2 final 关键字的语法

• 修饰类：class ClassName final { // 类的成员 };class Base { public: virtual void func() final; };
• 修饰虚函数：

2.3 final 关键字的使用示例

2.3.1 防止类被继承

class Base final {
public:
    void foo() {
        std::cout << "Base::foo()" << std::endl;
    }
};

// 下面的代码将无法通过编译，因为 Base 被声明为 final
// class Derived : public Base {
// public:
//     void foo() {
//         std::cout << "Derived::foo()" << std::endl;
//     }
// };

在这个例子中，Base 类被声明为 final，因此不能被其他类继承。如果尝试继承 Base 类，编译器会报错。

2.3.2 防止虚函数被重写

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

class Derived : public Base {
public:
    void foo() override {
        std::cout << "Derived::foo()" << std::endl;
    }
    // 下面的代码将无法通过编译，因为 bar() 在 Base 中被声明为 final
    // void bar() override {
    //     std::cout << "Derived::bar()" << std::endl;
    // }
};

在这个例子中，Base 类的 bar() 函数被声明为 final，因此在 Derived 类中不能重写该函数。如果尝试重写 bar() 函数，编译器会报错。

2.4 final 关键字的使用场景

• 设计意图明确：明确表示类或函数不应被进一步扩展或修改。
• 防止意外重写：避免派生类意外重写基类的重要虚函数。
• 优化机会：编译器可以对标记为 final 的虚函数进行去虚拟化优化。
• 接口控制：在框架或库设计中控制哪些部分可以被用户扩展。

2.5 final 关键字的注意事项

• final 不是虚函数声明的一部分，可以放在函数声明的任何位置（在参数列表后或函数体前）。
• final 只能用于虚函数和类。
• final 是一个标识符，在 C++11 之前可以用作变量名等，但在 C++11 及以后它有特殊含义。

final关键字在C++中的使用

三、override 关键字

3.1 override 关键字的基本概念

override 关键字用于显式地表明派生类中的成员函数是重写基类中的虚函数。使用 override 关键字可以提高代码的可读性和安全性，帮助开发者避免一些常见的错误。

3.2 override 关键字的语法

class Base {
public:
    virtual void func();
};

class Derived : public Base {
public:
    void func() override;
};

3.3 override 关键字的使用示例

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

class Derived : public Base {
public:
    void display() const override {
        std::cout << "Derived class display" << std::endl;
    }
};

int main() {
    Base* basePtr = new Derived();
    basePtr->display(); // 输出: Derived class display
    delete basePtr;
    return 0;
}

在这个例子中，Derived 类的 display() 函数重写了 Base 类的 display() 函数，并且使用了 override 关键字。这向编译器明确表明，display() 是对基类虚函数的重写。

3.4 override 关键字的作用

• 防止函数签名不匹配：如果函数签名不完全匹配（比如参数类型或个数不同），编译器会发出错误提示。
• 防止函数名拼写错误：如果函数名拼写错误或参数列表有误，编译器也会给出错误提示。

3.5 override 关键字的使用场景

当派生类需要重写基类中的虚函数时，通常会使用 override 关键字。这种用法可以提高代码的可读性和安全性，防止因为函数签名不同而导致的错误。

3.6 override 关键字的注意事项

• override 只能用于派生类中重写基类的虚函数。
• 如果基类中没有对应的虚函数，或者函数签名不匹配，编译器将报错。

override关键字在C++中的使用

四、final 和 override 的组合使用

final 和 override 可以组合使用，表示一个虚函数在派生类中被重写，并且在该派生类中是最终的，不能被进一步重写。

class Base {
public:
    virtual void func() {
        std::cout << "Base::func()" << std::endl;
    }
};

class Derived : public Base {
public:
    void func() override final {
        std::cout << "Derived::func()" << std::endl;
    }
};

class MoreDerived : public Derived {
public:
    // 下面的代码将无法通过编译，因为 func() 在 Derived 中被声明为 final
    // void func() override {
    //     std::cout << "MoreDerived::func()" << std::endl;
    // }
};

在这个例子中，Derived 类的 func() 函数重写了 Base 类的 func() 函数，并且使用了 override 关键字。同时，func() 函数被声明为 final，因此在 MoreDerived 类中不能重写该函数。

五、总结

final 和 override 是 C++11 引入的两个非常有用的关键字，它们为类的继承和多态机制提供了更多的控制权和明确性。final 关键字用于指示一个类或成员函数不能被继承或覆盖，而 override 关键字用于明确指出派生类中的成员函数旨在覆盖基类中的同名虚拟函数。

通过对 final 和 override 关键字的理解和运用，我们可以更加安全、清晰地设计和实现 C++ 程序。在实际开发中，合理地使用这两个关键字可以提高代码的可读性、安全性和可维护性，避免一些潜在的错误。希望本文能帮助你更好地掌握 final 和 override 关键字的使用，让你的 C++ 编程之路更加顺畅。