C++中静态和动态绑定的案例

Question

以下代码有 4 个类：Base1、Derived1（派生自 Base1）、Base2、Derived2（派生自 Base2）。两个基类都有整数 data1 和 display_data() 函数。两个派生类都有整数 data1 和 data2，以及 display_data() 函数。

我在我的代码中尝试了 4 种情况，可以在 main 函数中看到。我无法确定其中哪些是静态绑定的情况，哪些是动态的。我需要一些帮助。 我也想知道，这些情况中哪些可以被认为是“函数覆盖”。

代码：

#include <iostream>
using namespace std;

class Base1{
protected:
    int data1;

public:
    Base1(int idata1 = 0) {
        data1 = idata1;
    }

    void display_data() {
        cout << "Base1: " << data1 << endl;
    }
};

class Derived1 : public Base1 {
protected:
    int data2;

public:
    Derived1(int idata1 = 0, int idata2 = 0) {
        data1 = idata1;
        data2 = idata2;
    }

    void display_data() {
        cout << "Derived1: " << data1 << ' ' << data2 << endl;
    }
};


class Base2 {
protected:
    int data1;

public:
    Base2(int idata1 = 0) {
        data1 = idata1;
    }

    virtual void display_data() {
        cout << "Base2: " << data1 << endl;
    }
};

class Derived2 : public Base2 {
protected:
    int data2;

public:
    Derived2(int idata1 = 0, int idata2 = 0) {
        data1 = idata1;
        data2 = idata2;
    }

    void display_data() {
        cout << "Derived2: " << data1 << ' ' << data2 << endl;
    }
};

int main()
{
    // case 1
    Derived1 d1(1, 10);
    d1.display_data();

    // case 2
    Base1* d2 = new Derived1(2, 20);
    d2->display_data();

    // case 3
    Derived2 d3(3, 30);
    d3.display_data();

    // case 4
    Base2* d4 = new Derived2(4, 40);
    d4->display_data();

    return 0;
}

输出：

Derived1: 1 10
Base1: 2
Derived2: 3 30
Derived2: 4 40

Answer 1

这是我尝试用简单的方式解释它:)

当对象与基于对象的静态类型（了解其类的类型）的成员函数相关联时，会发生静态绑定。

当指针或引用与基于对象的动态类型（在运行时了解变量的实例）的成员函数相关联时，就会发生动态绑定。

继续阅读之前：动态绑定仅适用于指针或引用以及基类的虚函数。

第一次调用是静态绑定（也称为早期绑定），因为调用函数所需的一切都是已知的 在编译时。

    Derived1 d1(1, 10);
    d1.display_data();

您知道d1 实例是Derived1 类型的自动变量，然后它会调用 方法Derived1::display_data()。

• 第一个条件不正确：d1 既不是指针也不是引用。
• 第二个条件不行：Derived1::display_data 不是虚拟的。

第二次通话

    Base1* d2 = new Derived1(2, 20);
    d2->display_data();

我们看到变量d2的声明类型是Base1，但实例是Derived1（它 由于继承是正确的，因此Derived1 是Base1 类）。但你还不知道 如果它将调用的display_data 方法是来自Base1::display_data 的方法，或者是来自Base1::display_data 的方法 Derived1::display_data.

• 第一个条件没问题，因为我们有类型指针Base1* 的d2。
• 第二个条件不正确，因为Base1::display_data 不是虚拟的。因此它仍然 一个静态绑定，那么将被调用的函数是具有声明类型的函数，因此 代码将调用Base1::display_data

第三次通话

    // case 3
    Derived2 d3(3, 30);
    d3.display_data();

这将导致静态绑定，然后调用Derived3::display_data

• 第一个条件不正确：d3 既不是指针也不是引用。
• 第二个条件OK：Derived2::display_data是虚拟的。

第四次通话

    Base2* d4 = new Derived2(4, 40);
    d4->display_data();

这次是动态绑定。

• 第一个条件OK：d4是一个指针。
• 第二个条件OK：Derived2::display_data是虚拟的。 因此，它不会从声明的类型base2 调用该方法，而是调用该方法 从运行时声明的实例Derived2::display_data