#include <iostream> using namespace std; class B { public: B(int a) { cout << a << endl; } virtual void f() = 0; virtual void f1(int a) { cout << a; }; virtual void f2(int a)final{ cout << a; }; void f3(int c)final{ cout << c; } void f4(int b) { cout << b; } }; class D :public B { public: void f1(int b)override { cout << b; } void f2(int b)override { cout << b; } void f3(int b)override { cout << b; } void g1(char b)override { cout << b; } }; void main() { D d1; }

这段代码有一些问题，我来解释一下：

1. 类 B 中的构造函数需要传入一个 int 类型的参数，但是在 D 类中并没有传入参数，所以在创建 D 类对象时会出现错误。
2. 类 B 中的成员函数 f() 是纯虚函数，意味着 B 类是一个抽象类，无法直接创建对象，必须由派生类来实现该函数。
3. 类 B 中的成员函数 f1() 和 f2() 都是虚函数，而且 f2() 使用了 final 关键字，表示该函数在派生类中不能被覆盖，但是在 D 类中仍然定义了 f2() 并且使用了 override 关键字，这是错误的。
4. 类 B 中的成员函数 f3() 和 f4() 都不是虚函数，但是在 D 类中都使用了 override 关键字，这也是错误的。
5. 类 D 中还定义了一个成员函数 g1()，但是在类 B 中并没有该函数的声明，也没有使用 virtual 关键字，所以该函数并不是虚函数，也不是重载函数。

修改后的代码如下：

#include <iostream>
using namespace std;

class B {
public:
    B(int a) { cout << a << endl; }
    virtual void f() = 0;
    virtual void f1(int a) { cout << a; }
    virtual void f2(int a) final { cout << a; }
    virtual void f3(int c) final { cout << c; }
    void f4(int b) { cout << b; }
};

class D : public B {
public:
    D(int a) : B(a) {}
    void f() override { cout << "D::f()" << endl; }
    void f1(int b) override { cout << b; }
    // 不能覆盖 f2()
    // void f2(int b) override { cout << b; }
    void f3(int b) override { cout << b; }
    // 没有在 B 类中声明 g1()，也没有使用 virtual 关键字
    // void g1(char b) { cout << b; }
};

int main() {
    D d1(123);
    B* pb = &d1;
    pb->f();
    pb->f1(456);
    pb->f2(789);
    pb->f3(999);
    d1.f4(555);
    return 0;
}

修改后的代码中：

1. 在 D 类中添加了构造函数，通过调用 B 类的构造函数来初始化 B 类的成员变量。
2. 在 D 类中实现了 f() 函数，继承并重写了 B 类中的纯虚函数 f()。
3. 在 D 类中覆盖了 f1() 和 f3() 函数。
4. 注释掉了 f2() 函数的覆盖声明。
5. 注释掉了 g1() 函数的定义。
6. 在 main 函数中演示了对象的创建和成员函数的调用。