定义一个Base含有虚函数

在面向对象编程中，定义一个基类（Base）含有虚函数主要是为了实现多态性。虚函数是在基类中声明并标记为virtual的关键字，其目的允许派生类覆盖这个函数的行为。当通过基类指针或引用调用虚函数时，会根据实际指向的对象类型而不是指针类型来调用相应的函数，这就是动态绑定。

例如，在C++中，你可以这样做：

class Base {
public:
    virtual void display() { // 虚函数声明
        cout << "This is the base class display." << endl;
    }
};

class Derived : public Base {
public:
    virtual void display() override { // 派生类重写虚函数
        cout << "This is the derived class display." << endl;
    }
};

在这个例子中，`Derived`类重写了`Base`类的`display()`函数，当你使用`Base* ptr = new Derived();`创建一个`Derived`对象并通过`ptr->display();`调用时，会显示`Derived`类的版本。

相关问题

定义一个类base，该类含有虚函数display，然后定义他的两个派生类FirstB和Second B，这两个派生类均含有共有成员函数display。在主程序中，定义指向基类Base的指针变量ptr，并分别定义Base、FirstB、SecondB的对象b1、f1、s1，让ptr分别指向b1、f1、s1的起始地址，然后执行这些对象的成员函数display

下面是代码实现：

#include <iostream>
using namespace std;

class Base {
public:
    virtual void display() {
        cout << "This is Base class." << endl;
    }
};

class FirstB : public Base {
public:
    void display() {
        cout << "This is FirstB class." << endl;
    }
};

class SecondB : public Base {
public:
    void display() {
        cout << "This is SecondB class." << endl;
    }
};

int main() {
    Base b1;
    FirstB f1;
    SecondB s1;
    Base* ptr = nullptr;

    ptr = &b1;
    ptr->display();

    ptr = &f1;
    ptr->display();

    ptr = &s1;
    ptr->display();

    return 0;
}

输出结果为：

This is Base class.
This is FirstB class.
This is SecondB class.

由于基类中的display函数被声明为虚函数，因此在派生类中定义的同名函数会覆盖基类中的函数，即运行时会根据指针或者引用的实际类型来选择调用哪个版本的display函数。在上述代码中，分别定义了三个对象b1、f1、s1，它们的display函数分别被指向基类Base的指针变量ptr调用。根据实际类型的不同，分别输出了不同的结果。

实践作业： 定义一个类Base，该类含有虚成员函数display()，然后定义它的两个派生类FirstD 和SecondD，这两个派生类中均含有公有成员函数display()。

在C++中，实践这个作业可以按照以下步骤完成：

首先，创建一个名为`Base`的基类，并声明一个虚函数`display()`。

class Base {
public:
    virtual void display() const {
        // 默认显示信息
        std::cout << "This is the base class display.\n";
    }
};

接下来，定义两个派生类`FirstD`和`SecondD`，它们都从`Base`类继承并覆盖了`display()`函数。

class FirstD : public Base {
public:
    void display() const override {
        std::cout << "Displaying from FirstD.\n";
    }
};

class SecondD : public Base {
public:
    void display() const override {
        std::cout << "Displaying from SecondD.\n";
    }
};

现在，`FirstD`和`SecondD`类都有各自的`display()`实现，当使用指向它们的对象调用`display()`时，会分别执行各自类中的版本。

例如，下面的代码展示了如何使用这些类：

int main() {
    Base* basePtr = new FirstD();
    basePtr->display();  // 输出 "Displaying from FirstD."

    basePtr = new SecondD();
    basePtr->display();  // 输出 "Displaying from SecondD."

    delete basePtr;
    return 0;
}

在这个例子中，尽管`basePtr`是一个指向`Base`类型的指针，但由于`display()`是虚函数，实际调用的是派生类的具体实现，体现了多态性。