c++ 多态实现的原理（C++多态的原理）

目录

• 虚函数和多态
• 多态的作用
• 多态的一个例子
• 构造函数和析构函数中存在多态吗？
• 多态的实现原理
  • 虚函数表
• 虚析构函数
• 纯虚函数和抽象类
• 总结

虚函数和多态

虚函数：

• 在类的定义中，前面有 virtual 关键字的成员函数称为虚函数
• virtual 关键字只用在类定义里的函数声明中，写函数体时不用

比如：

?

1 2 3 4 5 6

class Base { virtual int Fun() ; // 虚函数 }; int Base::Fun() // virtual 字段不用在函数体时定义 { }

• 多态的表现形式 派生类的指针」
• 可以赋给「基类指针」通过基类指针调用基类和派生类中的同名「虚函数」时

1.若该指针指向一个基类的对象，那么被调用是 基类的虚函数；

2.若该指针指向一个派生类的对象，那么被调用 的是派生类的虚函数

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

#include <iostream> using namespace std; class Animal { public: virtual void speak() { cout << "动物在说话" << endl; } }; class Cat: public Animal { public: void speak() { cout << "猫在叫" << endl; } }; void test01() { Cat cat; Animal* p = &cat;//Animal *p=new Cat p->speak();//用哪个虚函数取决于 p 指向哪种类型的对象 } int main() { test01(); }

派生类的对象可以赋给基类「引用」通过基类引用调用基类和派生类中的同名「虚函数」时

1.若该引用引用的是一个基类的对象，那么被调 用是基类的虚函数

2.若该引用引用的是一个派生类的对象，那么被 调用的是派生类的虚函数

比如：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

#include <iostream> using namespace std; class Animal { public: virtual void speak() { cout << "动物在说话" << endl; } }; class Cat: public Animal { public: void speak() { cout << "猫在叫" << endl; } }; void test01() { Cat cat; Animal& p = cat; p.speak(); } int main() { test01(); }

多态的作用

在面向对象的程序设计中使用「多态」，能够增强程序的可扩充性，即程序需要修改或增加功能的时候，需要改动和增加的代码较少。

多态的一个例子

比如：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

class Base { public: void fun1() { fun2(); } virtual void fun2() // 虚函数 { cout << "Base::fun2()" << endl; } }; class Derived : public Base { public: virtual void fun2() // 虚函数 { cout << "Derived:fun2()" << endl; } }; int main() { Derived d; Base * pBase = & d; pBase->fun1(); return 0; }

请问输出结果是什么？

我们可能会认为pBase 指针对象虽然指向的是派生类对象，但是派生类里没有 fun1 成员函数，则就调用基类的 fun1 成员函数，Base::fun1() 里又会调用基类的 fun2 成员函数，所以输出结果是Base::fun2()

但结果却是Derived:fun2()，为什么会这样？

我们将代码修改一下

?

1 2 3 4 5 6 7 8

class Base { public: void fun1() { this->fun2(); // this是基类指针，fun2是虚函数，所以是多态 } }

this指针的作用域是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数，其作用就是指向成员函数所作用的对象，所以非静态成员函数中可以直接使用 this 来代表指向该函数作用的对象的指针。

pBase 指针对象指向的是派生类对象，派生类里没有 fun1 成员函数，所以就会调用基类的 fun1 成员函数，在Base::fun1() 成员函数体里执行 this->fun2() 时，实际上指向的是派生类对象的 fun2 成员函数。

所以我们需要注意：

• 在非构造函数，非析构函数的成员函数中调用「虚函数」，是多态

构造函数和析构函数中存在多态吗？

在构造函数和析构函数中调用「虚函数」，不是多态。编译时即可确定，调用的函数是自己的类或基类中定义的函数，不会等到运行时才决定调用自己的还是派生类的函数。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

#include <iostream> using namespace std; // 基类 class CFather { public: virtual void hello() // 虚函数 { cout << "hello from father" << endl; } virtual void bye() // 虚函数 { cout << "bye from father" << endl; } }; // 派生类 class CSon : public CFather { public: CSon() // 构造函数 { hello(); } ~CSon() // 析构函数 { bye(); } virtual void hello() // 虚函数 { cout << "hello from son" << endl; } }; int main() { CSon son; CFather* pfather; pfather = &son; pfather->hello(); //多态 return 0; }

结果为：

hello from son // 构造son对象时执行的构造函数
hello from son // 多态
bye from father // son对象析构时，由于CSon类没有bye成员函数，所以调用了基类的bye成员函数

多态的实现原理

「多态」的关键在于通过基类指针或引用调用一个虚函数时，编译时不能确定到底调用的是基类还是派生类的函数，运行时才能确定。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

class A { public: int i; virtual void Print() { } // 虚函数 }; class B { public: int n; void Print() { } }; int main() { cout << sizeof(A) << ","<< sizeof(B); return 0; }

在32位机子中：8 4

从上面的结果，可以发现有虚函数的类，多出了4 个字节，在 32 位机子上指针类型大小正好是 4 个字节，这多出 4 个字节的指针有什么作用呢？

虚函数表

每一个有「虚函数」的类（或有虚函数的类的派生类）都有一个「虚函数表」，该类的任何对象中都放着虚函数表的指针。「虚函数表」中列出了该类的「虚函数」地址。

多出来的 8 个字节就是用来放「虚函数表」的地址。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14

// 基类 class Base { public: int i; virtual void Print() { } // 虚函数 }; // 派生类 class Derived : public Base { public: int n; virtual void Print() { } // 虚函数 };

上面 Derived 类继承了 Base类，两个类都有「虚函数」，那么它「虚函数表」的形式可以理解成下图：

多态的函数调用语句被编译成一系列根据基类指针所指向的（或基类引用所引用的）对象中存放的虚函数表的地址，在虚函数表中查找虚函数地址，并调用虚函数的指令

虚析构函数

析构函数是在删除对象或退出程序的时候，自动调用的函数，其目的是做一些资源释放。

那么在多态的情景下，通过基类的指针删除派生类对象时，通常情况下只调用基类的析构函数，这就会存在派生类对象的析构函数没有调用到，存在资源泄露的情况。

比如：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// 基类 class A { public: A() // 构造函数 { cout << "construct A" << endl; } ~A() // 析构函数 { cout << "Destructor A" << endl; } }; // 派生类 class B : public A { public: B() // 构造函数 { cout << "construct B" << endl; } ~B()// 析构函数 { cout << "Destructor B" << endl; } }; int main() { A *pa = new B(); delete pa; return 0; }

输出结果：

construct A
construct B
Destructor A

从上面的输出结果可以看到，在删除 pa指针对象时，B 类的析构函数没有被调用

解决办法：把基类的析构函数声明为virtual

• 派生类的析构函数可以 virtual 不进行声明
• 通过基类的指针删除派生类对象时，首先调用派生类的析构函数，然后调用基类的析构函数，还是遵循「先构造，后虚构」的规则

?

1 2 3 4 5 6 7 8 9 10 11 12 13

// 基类 class A { public: A() { cout << "construct A" << endl; } virtual ~A() // 虚析构函数 { cout << "Destructor A" << endl; } };

输出结果：

construct A
construct B
Destructor B
Destructor A

纯虚函数和抽象类

纯虚函数： 没有函数体的虚函数

?

1 2 3 4 5 6 7

class A { public: virtual void Print( ) = 0 ; //纯虚函数 private: int a; };

包含纯虚函数的类叫抽象类

• 抽象类只能作为基类来派生新类使用，不能创建抽象类的对象
• 抽象类的指针和引用可以指向由抽象类派生出来的类的对象

?

1 2 3

A a; // 错，A 是抽象类，不能创建对象 A * pa ; // ok,可以定义抽象类的指针和引用 pa = new A ; // 错误, A 是抽象类，不能创建对象

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注服务器之家的更多内容！

原文链接：https://blog.csdn.net/m0_51174487/article/details/119280360