关于虚函数多态的例子

来看这一串代码

#include <bits/stdc++.h>

using namespace std;

class B {
public:
    virtual void f1() {
        cout << "B:f1()" << endl;
    }

    virtual void f2() {
        cout << "B:f2()" << endl;
    }

    void g() {
        cout << "B:g()" << endl;
        f1();
        f2();
    }
};

class D : public B {
public:
    virtual void f1() {
        cout << "D:f1()" << endl;
    }

    virtual void f3() {
        cout << "D:f3()" << endl;
    }

    void g() {
        cout << "D:g()" << endl;
        f1();
        f2();
    }
};

int main() {
    printf("0\n");
    D d;
    printf("1\n");
    D *pd = &d;
    printf("2\n");
    B *pb = &d;
    printf("3\n");
    B b = d;
    printf("4\n");
    b.f1();
    printf("5\n");
    b.f2();
    printf("6\n");
    b.g();
    printf("7\n");
    pb->f1();
    printf("8\n");
    pb->f2();
    printf("9\n");
    pb->g();
    printf("10\n");
    pd->f1();
    printf("11\n");
    pd->f2();
    printf("12\n");
    pd->f3();
    printf("13\n");
    pd->g();
}

---

结果:

0
1
2
3
4
B:f1()
5
B:f2()
6
B:g()
B:f1()
B:f2()
7
D:f1()
8
B:f2()
9
B:g()
D:f1()
B:f2()
10
D:f1()
11
B:f2()
12
D:f3()
13
D:g()
D:f1()
B:f2()

---

对于上述代码的解释:

0是调用了D的构造函数

1是创建了一个D类型的指针pd并指向了d的地址

2是创建了一个B类型的指针pb并指向了d的地址

3是调用了拷贝构造函数创建了一个B类型的b拷贝d

4调用了b.f1()所以输出
B:f1()

5调用了b.f2()所以输出
B:f2()

6调用了B.g()所以输出

B:g()
B:f1()
B:f2()

7 pb是指向d类型的指针,而且b中的f1f2是虚函数,所以动态的根据对象的类型调用D.f1
输出
D:f1()

8 输出B:f2(),是因为,对象d类型的,但是d类型没有f2,所以调用了父类b的f2

9
输出

B:g()
D:f1()
B:f2()

g()并不是虚函数
所以先输出B:g()
然后f1是虚函数,所以根据对象的类型,输出了D:f1()
最后,f2虽然是虚函数,但是D没有f2,所以输出了B:f2()

10
f1()是虚函数,所以输出D:f1()

11
虽然f2是虚函数,但是D没有f2,所以输出B:f2()

12
对象是D,指针类型也是D,而且只有D有f3,所以输出D:f3()

13
输出

D:g()
D:f1()
B:f2()

g()不是虚函数,指针类型是D,所以调用D.g()输出D:g(),因为D里有f1f2,而且f1是虚函数,对象类型是D,所以输出D:f1(),最后D没有f2,所以输出B:f2()