C++ override关键字使用详解

关于C++中的override关键字，我可以为你提供详细的使用说明和示例。

什么是override关键字

override是一个C++11引入的关键字，它用于在子类中对父类中已有的虚函数进行重写（override）。通过使用override关键字，我们可以显式地告诉编译器，这个函数是我们有意覆盖父类中的虚函数。

使用override关键字的原因

在没有override关键字之前，我们在子类中重写父类中的虚函数时，可能会由于一些类型或者参数不匹配的问题导致重写失败，而不易被发现。使用override关键字，可以帮助我们在编译期间发现这些问题，提高程序的可靠性和健壮性。

override关键字的语法格式

通过以下语法，我们可以在子类中使用override关键字对父类中的虚函数进行重写：

class SubClass : public BaseClass
{
public:
     virtual void virtualFunction() override;
};

在这个例子中，我们使用override关键字对父类中的virtualFunction函数进行了重写，并在子类中实现了这个重写函数。

需要注意的是：

• 父类中需要声明虚函数（使用virtual关键字）。
• 父类中的虚函数和子类的虚函数必须满足函数名和参数列表的一致性，否则无法重写。
• 子类的虚函数必须使用override关键字进行修饰。

override关键字的示例

下面我们来看两个简单的示例，说明override关键字的使用方法和作用。

示例1：

假设我们有一个基类People，我们在其中定义了一个虚函数int getAge()，在子类Student中对其进行重写。代码如下：

#include<iostream>
using namespace std;

class People
{
public:
    People(){}
    virtual int getAge(){ return 0; }
};

class Student : public People
{
public:
    Student() : People()
    {
        age = 20;
    }
    virtual int getAge() override { return age; }//重写父类中的虚函数
private:
    int age;
};

int main()
{
    People* person1 = new People();
    People* person2 = new Student();

    cout << person1->getAge() << endl;
    cout << person2->getAge() << endl;

    delete person1;
    delete person2;
    return 0;
}

在代码中，我们在子类Student中通过override关键字对父类People的虚函数进行了重写。使用override关键字后，编译器会在编译期间检查我们是否正确地重写了父类的虚函数。如果不正确，编译会失败。

在main函数中，我们分别定义了两个指向People类型的指针，一个指向People对象，一个指向Student对象，并调用它们的getAge函数。运行结果如下：

0
20

可以看到，person1指针指向的是People对象，因此调用getAge函数返回的是父类中的默认值0；而person2指针指向的是Student对象，调用getAge函数返回的是其子类中age成员变量的值20。

示例2：

我们再看一个示例，假设我们有一个父类A和一个子类B，此时我们在B类中写一个虚函数，但是我们并没有使用override关键字。代码如下：

#include<iostream>
using namespace std;

class A
{
public:
    A(){}
    virtual void doSomething()
    {
        cout << "do something in class A!" << endl;
    }
};
class B : public A
{
public:
    B() : A()
    {

    }
    virtual void doSomething()
    {
        cout << "do something in class B!" << endl;
    }
};

int main()
{
    A* a = new A();
    B* b = new B();
    a->doSomething();
    b->doSomething();
    delete a;
    delete b;
    return 0;
}

在这个示例中，我们没有使用override关键字，但是我们在子类B中重新定义了父类A中的虚函数doSomething。在main函数中，我们分别定义了指向A和B对象的指针，并调用它们的doSomething函数进行测试。

运行结果如下：

do something in class A!
do something in class B!

可以看到，即使我们没有使用override关键字，但是在B类中重写了A类中的虚函数，在实际调用中也会正确地调用B类中的doSomething函数。

需要注意的是：虽然在这个示例中是正确的，但是在实际的编程中，如果不使用override关键字，可能会导致一些类型或者参数不匹配的问题。因此，建议在项目中使用override关键字来提高程序的健壮性。