C++ — 继承和多态的基础虚函数类

港控/mmm° 2022-06-18 04:25 280阅读 0赞

# 虚函数类 #

—————————————————————————————

上一个博客继承中我们提到虚拟继承，现在我们来探究这种的虚函数，虚函数类的成员函数前面加 virtual 关键字，则这

个成员 函数称为虚函数，不要 小看这个虚函数，他可以解决继承中许多棘手的问题，而对于多态 那他更重要了，没有它就

没有多态， 所以这个知识点非常重要，以及后面介绍的虚函 数表都极其重要，一定要 认真的理解~ 现在开始概念 虚函数就

又引出一个概念， 那就是重写（覆盖），当在子类的定义了一个与父类完全相同的虚函数 时 ，则称子类的这个函数重写（

也称覆盖）了父类的这 个虚函数。这里先提一下虚函数表，后面会讲到 的，重写 就是将子类里面的虚函数表里的被重写 父

类 的函数地址全都改成子类 函数的地址。

**纯虚函数**

在成员函数的形参后面写上=0，则成员函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类）

抽象类不能实例化出对象。纯虚函数在派生类 中重新定义以后，派生类才能实例化出对象。

看一个例子：

class Person
    {
         virtual void Display () = 0;   // 纯虚函数
    protected :
         string _name ;          // 姓名
    };
    
    class Student : public Person
    {};

先总结一下概念：

1.派生类重写基类的虚函数实现多态，要求函数名、参数列表、返回值完全相同。（协变除外）

2.基类中定义了虚函数，在派生类中该函数始终保持虚函数的特性。

3.只有类的成员函数才能定义为虚函数。

4.静态成员函数不能定义为虚函数。

5.如果在类外定义虚函数，只能在声明函数时加virtual，类外定义函数时不能加virtual。

6.不要在构造函数和析构函数里面调用虚函数，在构造函数和析构函数中，对象是不完整的，可能会发生 未定义的行为。

7.最好把基类的析构函数声明为虚函数。（why？另外析构函数比较特殊，因为派生类的析构函数跟基类的 析构函数名称

不一 样，但是构成覆盖，这里 是因为编译器做了特殊处理）

8.构造函数不能为虚函数，虽然可以将operator=定义为虚函数，但是最好不要将operator=定义为虚函数， 因为容易使用

时容 易引起混淆.

![Center][]

上面概念大家可能都会问一句为什么要这样? 这些内容在接下来的知识里都能找到答案~ 好了那么我们今天的主角**虚函数**

登场!!!!何为虚函数表，我们写一个程序，调一个监视窗口就知道了。

下面是一个有虚函数的类：

#include<iostream>
    #include<windows.h>
    using namespacestd;
     
    class Base
    {
    public:
             virtual void func1()
             {}
     
             virtual void func2()
             {}
     
    private:
             inta;
    };
     
    void Test1()
    {
             Base b1;
    }
     
    int main()
     
    {
             Test1();
             system("pause");
             return0;
    }

我们现在点开b1的监视窗口

![Center 1][]

这里面有一个\_vfptr，而这个\_vfptr指向的东西就是我们的主角，虚函数表。一会大家就知道了，无论是单继承还是多继

承甚至于我们的菱形继承虚函数表都会有不同的形态，虚函数表是一个很有趣的东西。

![Center 2][]

#  #

#     #

# 我们来研究一下单继承的内存格局 #

仔细看下面代码：

#include<iostream>
    #include<windows.h>
    using namespace std;
     
     
    class Base
    {
    public:
             virtual void func1()
             {
                       cout<< "Base::func1"<< endl;
             }
     
             virtual void func2()
             {
                       cout<< "Base::func2"<< endl;
             }
     
    private:
             inta;
    };
     
    class Derive:public Base
    {
    public:
             virtual void func1()
             {
                       cout<< "Derive::func1"<< endl;
             }
     
             virtual void func3()
             {
                       cout<< "Derive::func3"<< endl;
             }
     
             virtual void func4()
             {
                       cout<< "Derive::func4"<< endl;
             }
     
    private:
             int b;
    };

对于Derive类来说，我们觉得它的虚表里会有什么？

首先子类的fun1()重写了父类的fun1()，虚表里存的是子类的fun1(),接下来父类的fun2(),子类的fun3(),fun4()都是虚

函数，所以虚表里会有4个元素，分别为子类的fun1(),父类fun2(),子类fun3()，子类fun4()。然后我们调出监视窗口看

我们想的到底对不对呢？

![Center 3][]

我预计应该是看到fun1(),fun2(),fun3(),fun4()的虚函数表，但是呢这里监视窗口只有两个fun1(),fun2()，难道我们

错了？这里并不是这样的，只有自己靠得住，我觉得这里的编译器有问题，那我们就得自己探索一下了。 但是在探索之

前我们必须来实现一个可以打印虚函数表的函数。

typedef void(*FUNC)(void);
    void PrintVTable(int* VTable)
    {
             cout<< " 虚表地址"<<VTable<< endl;
     
             for(inti = 0;VTable[i] != 0; ++i)
             {
                       printf(" 第%d个虚函数地址 :0X%x,->", i,VTable[i]);
                       FUNC f = (FUNC)VTable[i];
                       f();
             }
     
             cout<< endl;
    }
     
     
    int main()
    {
             Derive d1;
             PrintVTable((int*)(*(int*)(&d1)));
             system("pause");
             return0;
    }

下图来说一下他的缘由：

![Center 4][]

我们来使用这个函数，该函数代码如下:

//单继承
    class Base
    {
    public:
    	virtual void func1()
    	{
    		cout << "Base::func1" << endl;
    	}
    
    	virtual void func2()
    	{
    		cout << "Base::func2" << endl;
    	}
    
    private:
    	int a;
    };
    
    class Derive :public Base
    {
    public:
    	virtual void func1()
    	{
    		cout << "Derive::func1" << endl;
    	}
    
    	virtual void func3()
    	{
    		cout << "Derive::func3" << endl;
    	}
    
    	virtual void func4()
    	{
    		cout << "Derive::func4" << endl;
    	}
    
    private:
    	int b;
    };
    typedef void(*FUNC)(void);  
    void PrintVTable(int* VTable)  
    {  
             cout<< " 虚表地址"<<VTable<< endl;  
       
             for(inti = 0;VTable[i] != 0; ++i)  
             {  
                       printf(" 第%d个虚函数地址 :0X%x,->", i,VTable[i]);  
                       FUNC f = (FUNC)VTable[i];  
                       f();  
             }  
       
             cout<< endl;  
    }  
       
       
    int main()  
    {  
             Derive d1;  
             PrintVTable((int*)(*(int*)(&d1)));  //重点
             system("pause");  
             return0;  
    }

这里我就要讲讲这个传参了，注意这里的传参不好理解，应当细细的"品味".

**PrintVTable((int\*)(\*(int\*)(&d1)));**

首先我们肯定要拿到d1的首地址，把它强转成int\*，让他读取到前4个字节的内容（也就是指向虚表的地址），再然后

对 那个 地址解 引用，我们已经拿 到虚表的首地址的内容(虚表里面存储的第一个函数的地址)了，但是此时这个变量的类

型解 引用后 是int，不能够 传入函数，所以我们再对他进行一个 int\*的强制类型转换，这样我们就传入参数了，开始函

数执行 了 ，我们一切 都是在可控的情况 下使用强转，使用强转你必须要特别清楚的知道内存的分 布结构。

最后我们来看看输出结果：

![20170831230058393][]

![Image 1][]

到底打印的对不对呢？ 我们验证一下：

![20170831230732300][]

![Image 1][]

这里我们通过&d1的首地址找到虚表的地址，然后访问地址查看虚表的内容，验证我们自己写的这个函数是正确的。

这里 VS 还有一 个bug，当你第一次 打印虚表时程序可能会崩溃，不要担心你重新生成解决方案，再运行一次就可以了

因为当你 第一 次打印是你虚 表最后一个地方可能没有放0，所以你 就有可能停不下来然后崩溃。）我们可以看到d1的

虚表并不是监视 器里面打 印的那个样子的.

所以有时候VS也会有bug，不要太相信别人，还是自己靠 得住。哈哈哈，臭美一下~

#     #

#    我们来研究一下多继承的内存格局 #

探究完了单继承，我们来看看多继承，我们还是通过代码调试的方法来探究对象模型

看如下代码：

class Base1
    {
    public:
    	virtual void func1()
    	{
    		cout << "Base1::func1" << endl;
    	}
    
    	virtual void func2()
    	{
    		cout << "Base1::func2" << endl;
    	}
    
    private:
    	int b1;
    };
    
    class Base2
    {
    public:
    	virtual void func1()
    	{
    		cout << "Base2::func1" << endl;
    	}
    
    	virtual void func2()
    	{
    		cout << "Base2::func2" << endl;
    	}
    
    private:
    	int b2;
    };
    
    
    class Derive : public Base1, public Base2
    {
    public:
    	virtual void func1()
    	{
    		cout << "Derive::func1" << endl;
    	}
    
    	virtual void func3()
    	{
    		cout << "Derive::func3" << endl;
    	}
    
    private:
    	int d1;
    };
    
    typedef void(*FUNC) ();
    void PrintVTable(int* VTable)
    {
    	cout << " 虚表地址>" << VTable << endl;
    
    	for (int i = 0; VTable[i] != 0; ++i)
    	{
    		printf(" 第%d个虚函数地址 :0X%x,->", i, VTable[i]);
    		FUNC f = (FUNC)VTable[i];
    		f();
    	}
    	cout << endl;
    }
    
    
    void Test1()
    {
    	Derive d1;
    	//Base2虚函数表在对象Base1后面  
    	int* VTable = (int*)(*(int*)&d1);
    	PrintVTable(VTable);
    	int* VTable2 = (int *)(*((int*)&d1 + sizeof (Base1) / 4));
    	PrintVTable(VTable2);
    }
    int main()
    {
    	Test1();
    	system("pause");
    	return 0;
    }

现在我们现在知道会有两个虚函数表，分别是Base1和Base2的虚函数表，但是呢！我们的子类里的fun3()函数怎么

办？它 是放 在Base1里还是Base2里还 是自己开辟一个虚函数表呢？ 我们先调一下监视窗口：

![Center 5][]

监视窗口又不靠谱了。。。。 完全没有找到fun3(). 那我们直接看打印出来的虚函数表。

![Center 6][]

现在很清楚了，fun3()在Base1的虚函数表中，而Base1是先继承的类，好了现在我们记住 这个结论，当涉及多继承

时，子 类的 虚函数会存在先继承的那 个类的虚函数表里。记住了！

我们现在来看多继承的对象模型：

![Center 7][]

# 现在我们来结束一下上面我列的那么多概念现在我来逐一的解释为什么要这样. #

1.为什么静态成员函数不能定义为虚函数?

**因为静态成员函数它是一个大家共享的一个资源，但是这个静态成员函数没有this指针，而且虚函数变只有对象**

**才能能调到，但** **是静态成员函数不需要对象就可以调用，所以这里是有冲突的.**

**2.为什么不要在构造函数和析构函数里面调用虚函数？**

**构造函数当中不适合用虚函数的原因是:在构造对象的过程中，还没有为“虚函数表”分配内存。所以，这个调用**

**也是** **违背** **先实例化后调用的准则**

**析构函数当中不适用虚函数的原因是：一般析构函数先析构子类的，当你在父类中调用一个重写的fun()函数，虚**

**函数表里** **面就是子类的fun()函数，这时候已经子类已经析构了，当你调用的时候就会调用不到.**

# 现在我在写最后一个知识点，为什么尽量最好把基类的析构函数声明为虚函数？？ #

现在我们再来写一个例子，我们都知道平时正常的实例化对象然后再释放是没有一点问题的， 但是 现在我这里举一个特例：

我们都知道父类的指针可以指向子类，现在呢我们我们用一个父类的指针new一个子类的对象。

//多态  析构函数
    class Base
    {
    public:
    	virtual void func1()
    	{
    		cout << "Base::func1" << endl;
    	}
    
    	virtual void func2()
    	{
    		cout << "Base::func2" << endl;
    	}
    
    	virtual ~Base()
    	{
    		cout << "~Base" << endl;
    	}
    
    private:
    	int a;
    };
    
    class Derive :public Base
    {
    public:
    	virtual void func1()
    	{
    		cout << "Derive::func1" << endl;
    	}
    	virtual ~Derive()
    	{
    		cout << "~Derive"<< endl;
    	}
    private:
    	int b;
    };
    
    void Test1()
    {
    	Base* q = new Derive;
    	delete q;
    }
    int main()
    {
    	Test1();
    	system("pause");
    	return 0;
    }

这里面可能会有下一篇要说的多态，所以可能理解起来会费劲一点。

注意这里我先让父类的析构函数不为虚函数(去掉virtual)，我们看看输出结果：

![Center 8][]

这里它没有调用子类的析构函数，因为他是一个父类类型指针，所以它只能调用父类的析构函数， 无权访问子类的析构函

数 ，这种调用方法会导致内存 泄漏，所以这里就是有缺陷的，但是C++是不会 允许自己有缺陷，他就会想办法解决这个问

题，这 里就运用到了我们下次要讲的多态 。 现在我们让加上 为父类析构函数加上virtual，让它变回虚函数，我们再运行一

次程序的：

![Center 9][]

诶！ 子类的虚函数又被调用了，这里发生了什么呢？？ 来我们老方法打开监视窗口。

![Center 10][]

刚刚这种情况就是多态，多态性可以简单地概括为“一个接口，多种方法”，程序在运行时才决定调用 的函数，它是面

向 对象 编程领域的核心概念。这 个我们下一个博客专门会总结多态.

当然虚函数的知识点远远没有这么一点，这里可能只是冰山一角，比如说菱形继承的虚函数表是什么样？ 然后菱形虚拟

继 承又 是什么样子呢？ 这些等 我总结一下会专门写一个博客来讨论菱形继承。 虚函数表我们应该已经知道是什么东西了

，也 知道单继 承和多继承中它的应用，这些应该就足够了，这 些 其实都是都是为你让你更好的理解继承和多态，当然你

一定到 分清楚重写，重 定义，重载的他们分别的含义是什么. 这一块可能有点绕，但是我们必 须要掌握.

这些就是虚函数的一点简单见解，有问题还请大家指出，让我改正，有什么不足的也请指出来，让我可以查漏补缺~谢谢~

[Center]: /images/20220618/eb52111fce184adab16ff42cc5288ed5.png
[Center 1]: /images/20220618/694c1fa645be483ab2547e788a7a2647.png
[Center 2]: /images/20220618/90f595a1f5d1402f9bd813af1a4c7031.png
[Center 3]: /images/20220618/5ee5b7ef4efd4a4da8e146ed3068c282.png
[Center 4]: /images/20220618/96a1cf943efd4cd39482dee13596f0bf.png
[20170831230058393]: /images/20220618/38dbd249044e48e294a06eb854c2ff83.png
[Image 1]: 
[20170831230732300]: /images/20220618/53a15ee7d28d4dca8a0431f029ecf3cc.png
[Center 5]: /images/20220618/92d8aa6291c64edc8040672ab4880414.png
[Center 6]: /images/20220618/5581641574ae4af6b8ae60dad4a1b559.png
[Center 7]: /images/20220618/50c6e6ac5ef0490a8f00f478207fcc1a.png
[Center 8]: /images/20220618/1bb14ef5a073427ea9588ab01acd457d.png
[Center 9]: /images/20220618/b8ce93fd6dc74bec99c3c03407bddbad.png
[Center 10]: /images/20220618/0194a86ad73640759a88f01fbbc9c54b.png