【转】C++中虚函数动态绑定的实现

最新推荐文章于 2023-11-16 19:34:29 发布

wangyanlong0107

最新推荐文章于 2023-11-16 19:34:29 发布

阅读量435

点赞数 1

分类专栏： c++ 文章标签： c/c++

本文链接：https://blog.csdn.net/wangyanlong0107/article/details/84238954

版权

c++ 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

说实话，我们老师没有教过C++，我在大一的时候自己学的。虽然说学过了，但是没有用它写过程序。现在都是用C写，虽然比较麻烦，但是感觉很爽。觉得自己现在的思想转变不过来，很不适应面向对象编程。由于这个原因，我在写这篇文章之前，先请我学过C++的同学把这篇文章给我找了找错，现在经过改进应该已经没有错误了。当然了，如果哪位高手发现了错误，欢迎提出来，我再改，呵呵....感谢鞠善哲和他同学一起帮我找错。

写这篇文章不是写自己的心得了，而是给大家提供一个很好的解决问题的方案。具体是什么大家看了就知道。文章前面是对多态和虚函数的简单介绍，后面是重点，呵呵....不多说了，下面开始。

     多态性是面向对象编程的一个重要的特征。如果一种语言只支持类而不支持多态，是不能被称为面向对象语言的，只能说是基于对象的，如VB就属于此类。
    简单的说多态的意思就是指具有不同功能的函数可以用同一个函数名，这样就可以用一个函数名调用不同内容的函数。
    从系统实现的角度看，多态性可分为两类：静态多态和动态多态。函数重载和运算符重载实现的多态属于静态多态，在程序编译时系统就能决定调用的是哪个函数，因此静态多态性又称编译时的多态性。（能够达到这个效果的原因我认为是重载的时候函数的参数有了改变（数量和类型），使得编译器能够分辨重载前和重载后的函数，即使它们有着相同的函数名）
    静态多态性是通过函数的重载实现的（运算符重载实质上也是函数重载）。动态多态性是在程序运行过程中才动态的确定操作所针对的对象。它又称运行时的多态性。动态多态性是通过虚函数实现的。
    下面我主要说虚函数使用方法和动态关联的实现。有关虚函数的介绍什么的我就不多说了。
    虚函数使用方法：
    （1）在基类中用virtual声明成员函数为虚函数。这样就可以在派生类中重新定义此函数，为它赋予新的功能，并能方便的被调用。
    （2）在派生类中重新定义此函数，要求函数名、函数类型、函数参数个数和类型都要与基类的虚函数相同，并根据派生类的需要重新定义函数体。如果在派生类中没有对基类的虚函数重新定义，则派生类简单地继承其直接基类的虚函数。
    （3）定义一个指向基类对象的指针变量，并使它指向同一类族中的某一对象。（这里应该注意一个基类类型的指针指向它的子类对象的时候，需要进行指针类型转换，先把子类对象的指针转换为基类的指针，然后再把值赋给那个基类类型的指针。所以这时候基类指针指向的是子类对象中基类的部分。如果不使用虚函数的话，是无法通过基类指针去调用子类对象中的非基类成员函数的，但是我们却可以用基类指针调用子类中已重新定义的虚函数，这是虚函数的一个功能）
    （4）通过该指针变量调用此虚函数，此时调用的就是指针变量指向的对象的同名函数。
     下面举个例子。
#0001 #include <iostream.h>
#0002 class CShape
#0003 {
#0004 public:
#0005 virtual void display() { cout << "Shape \n"; }
#0006 };
#0007 //------------------------------------------------
#0008 class CEllipse : public CShape
#0009 {
#0010 public:
#0011 virtual void display() { cout << "Ellipse \n"; }
#0012 };
#0013 //------------------------------------------------
#0014 class CCircle : public CEllipse
#0015 {
#0016 public:
#0017 virtual void display() { cout << "Circle \n"; }
#0018 };
#0019 //------------------------------------------------
#0020 class CTriangle : public CShape
#0021 {
#0022 public:
#0023 virtual void display() { cout << "Triangle \n"; }
#0024 };
#0025 //------------------------------------------------
#0026 class CRect : public CShape
#0027 {
#0028 public:
#0029 virtual void display() { cout << "Rectangle \n"; }
#0030 };
#0031 //------------------------------------------------
#0032 class CSquare : public CRect
#0033 {
#0034 public:
#0035 virtual void display() { cout << "Square \n"; }
#0036 };
#0037 //------------------------------------------------
#0038 void main()
#0039 {
#0040 CShape aShape;
#0041 CEllipse aEllipse;
#0042 CCircle aCircle;
#0043 CTriangle aTriangle;
#0044 CRect aRect;
#0045 CSquare aSquare;
#0046 CShape* pShape[6] = { &aShape,   //注意数组的类型CShape*
#0047 　　 &aEllipse,
#0048 　　 &aCircle,
#0049 　　 &aTriangle,
#0050 　　 &aRect,
#0051 　　 &aSquare };
#0052
#0053 for (int i=0; i< 6; i++)
#0054 pShape[i]->display();
#0055 }
#0056 //------------------------------------------------
得到的结果是：
Shape
Ellipse
Circle
Triangle
Rectangle
Square

如果把所有类中的virtual关键字去掉，则得到的结果就成为：
Shape
Shape
Shape
Shape
Shape
Shape

从上面的例子可以看出，我们一直执行的都是一个函数display()，但是程序在执行时运行的却是不同对象的display()函数，这就叫做动态关联，或者动态绑定。因为是在运行时将虚函数与类对象“绑定到一块儿的”。

那么C++是怎么实现这个功能的呢？

为了达到动态绑定的目的，C++编译器通过一个表格，在执行期间“间接”呼叫实际上欲绑定的函数（注意“间接”这个字眼）。这样的表格称为虚函数表（vtable）。每一个“内含虚函数的类”，编译器都会为它做出一个虚函数表，表中的每一个元素都指向一个虚函数的地址。此外，编译器当然也会为类加上一项成员变量，是一个指向该虚函数表的指针（vptr）。举例：

class Class1 {
public :
data1;
data2;
memfunc();
virtual vfunc1();
virtual vfunc2();
virtual vfunc3();
};
Class1 的实际对象在内存中实践占据这样的空间：