多态的定义、重写、原理

创始人

2024-06-01 17:41:39

0次

多态

文章目录

多态
- 多态的定义和条件
- - 协变（父类和子类的返回值类型不同）
  - - 函数隐藏和虚函数重写的比较
  - 析构函数的重写
  - 关键字final和override
- 抽象类
- 多态的原理
- - 单继承和多继承的虚函数表
  - - 单继承下的虚函数表
    - 多继承下的虚函数表

多态的定义和条件

定义：多态是在不同继承关系的对象上，去调用同一函数，从而产生不同的行为。

在继承中构成多态还需要两个条件：

一是被调用的函数必须是虚函数（函数用virtual关键字修饰）。并且要求父类和子类的虚函数符合三同即函数名、参数、返回值类型相同，即为虚函数的重写/覆盖（子类的虚函数重写了父类虚函数）

二是必须是父类的指针、引用去调用虚函数

如图，有个Person类里面实现了一个BuyTicket函数，还有个student类里面也实现了一个BuyTicket函数。此时student类继承了Person类，两者的BuyTicket函数都是虚函数，满足函数名、参数、返回值相同，并且在fun函数里参数是用的父类的引用去调用。此时Person和student的BuyTicket就构成了多态。通过不同的对象去调用同一个函数产生了不同的行为！

另外，子类的函数可以不是虚函数，但父类的函数必须是虚函数

协变（父类和子类的返回值类型不同）

三同中，返回值类型可以不同，但要求返回值是父子类关系的一个引用或者指针

就算用的别的类型也可以。这里我创建了一个父子类关系类型A，类型B用来做返回值

函数隐藏和虚函数重写的比较

我们知道，父类和子类的函数名相同就构成了函数隐藏或者重定义。而多态的要求比隐藏更严格，虚函数的重写必须满足三同（函数名、参数、返回值类型相同），其中一个不相同即为函数隐藏。

函数重载	函数隐藏/重定义	函数重写/覆盖
同一作用域；函数名相同；参数列表不同（参数类型、个数、顺序）；返回值不影响	不同作用域（父类和子类）；函数名相同；参数列表不同时，基类有无virtual修饰都是；参数列表相同时，基类没有virtual修饰是；返回值可以不同	不同作用域（父类和子类）；函数名相同；参数列表相同；返回值类型相同；基类必须要有virtual修饰；必须是由父类的引用或者指针调用虚函数；返回值类型不同时，返回值类型也必须是父子类关系的指针或者引用—协变

由此可见，多态调用与调用的对象有关，普通调用与调用的对象类型有关

析构函数的重写

这里是普通调用析构函数，目前没什么问题

然而当有父类的指针指向或者父类的引用时，子类的析构函数没有执行，产生了内存泄漏。原因：子类的切片，指针或者引用指向父类那部分，所以子类就只调用了父类的析构函数。

这时候就需要用到函数的重写。

只需要给父类的析构函数加上virtual修饰即可。编译后，编译器对父类和子类的析构函数名称都统一处理成destructor

关键字final和override

前面都介绍的是如何实现函数的重写，那么一个虚函数不想被重写呢？

给虚函数加上关键词final加以修饰表示虚函数不能被重写

那一个类不想被继承呢？

一是构造函数私有

二是用final修饰，即可理解为最后的类

override修饰子类函数可用来在编译期间检查子类函数是否对父类函数完成了重写

抽象类

定义：在虚函数后面写=0，则这个函数为纯虚函数。包括纯虚函数的类称抽象类或接口类。抽象类不能实例化出对象，其子类也不能实例化出对象，除非子类重写了纯虚函数。纯虚函数规定了子类必须重写，即接口继承。

虚函数继承通过与普通函数的继承对比，普通函数继承为实现继承，派生类继承了基类，可以用基类的函数。而虚函数虚函数是一种接口继承。派生类继承的是接口，目的是为了重写，达到多态。

多态的原理

接下来看一个含有虚函数的类的大小

类A里有一个int类型和一个char类型，合计5个字节，加上虚函数dave，虚函数里有虚表指针4个字节（32位系统下），合计9个字节，内存对齐后是12个字节

我们打开调试窗口可以看到有个指针_vfptr

那如果类里多几个虚函数呢？？

class A
{
public:virtual void dave1(){}virtual void dave2(){}virtual void dave3(){}
private:int _a;char _b;
};int main()
{A aa;cout << "带有虚函数的类的大小：" << sizeof(aa) << endl;return 0;
}

类里再多的虚函数也只有一个虚表指针，指针指向一个虚函数表，表里存放着指向各个虚函数的指针，该虚表本质上是函数指针数组。

class A
{
public:virtual void Func1(){cout << "A::Func1()" << endl;}virtual void Func2(){cout << "A::Func2()" << endl;}void Func3(){cout << "A::Func3()" << endl;}
private:int _a = 1;
};
class B : public A
{
public:virtual void Func1(){cout << "B::Func1()" << endl;}
private:int _b = 2;
};
int main()
{A a;B b;return 0;
}

这里B类继承了A类，并完成了对虚函数fun1的重写，而没有对A类的虚函数fun2重写。可以看到两个虚函数都继承了下来，但fun1的地址该变了，而fun2的地址没有改变。可以猜测：子类在对父类函数的重写时，是先把父类的虚函数表拷贝一份，然后对要重写的函数进行覆盖。

那普通调用和多态调用的原理有差别吗？

这里ptr指针对fun3函数调用为普通调用，而对fun1函数调用为多态调用

调试时转到反汇编，可以看到普通调用是直接call函数，而多态调用则步骤很多，还用到了各种寄存器。

这里更加应证了普通调用为编译时绑定，即在编译期间就确定了程序的行为，也称静态多态，比如函数重载。

而多态调用为运行时绑定，在程序运行期间根据具体的类型确定程序的行为，调用具体的函数，也称动态多态。

实际上，普通调用时，是根据指针指向的类型进行调用。ptr指向b对象的fun3是A类fun3的切片，跟ptr指向a对象的fun3无异。所以是直接call A类的fun3函数。

而多态调用是根据指针指向对象的类型有关。ptr指向b对象的fun1，**由于fun1是虚函数，该指向虚函数的指针进入了虚数表，那么指针就进入虚数表里找，找到的是类型B对类型A重写的fun1虚函数的指针，那么调用的就是重写的fun1函数，注意该切片部分是被重写的！**而ptr指向a对象的fun1也是进入虚数表里找，找到的调用的即是fun1虚函数本身。

而多态能完成指向谁调用谁其根本就是由于虚数表。

那虚表在哪里呢？

找到虚表存放的第一个指针的地址就能找到虚表的位置。

int main()
{int a = 0;cout << "栈:" << &a << endl;int* p1 = new int;cout << "堆:" << p1 << endl;const char* str = "hello world";cout << "代码段/常量区:" << (void*)str << endl;static int b = 0;cout << "静态区/数据段:" << &b << endl;A aa;cout << "虚表:" << (void*)*((int*)&aa) << endl;return 0;}

通过测试，可以看到虚表的位置离代码段和静态区很近

并且同个类型的虚表是共享的。

单继承和多继承的虚函数表

单继承下的虚函数表

接下来来看派生类对象的虚数表模型

typedef void(*vfptr)();//定义了函数指针
void PrintVtalbe(vfptr vtable[])//传函数指针数组
{for (int i = 0; vtable[i] != nullptr; i++){printf("[%d]:%p->", i, vtable[i]);vtable[i]();    }cout << endl;
}
class A {
public:virtual void func1() { cout << "Base::func1" << endl; }virtual void func2() { cout << "Base::func2" << endl; }
private:int _a;
};
class B :public A {
public:virtual void func1() { cout << "Derive::func1" << endl; }virtual void func3() { cout << "Derive::func3" << endl; }
private:int _b;
};
int main()
{A a;B b;vfptr* vtab1 = (vfptr*)(*((void**)&a));vfptr* vtab2 = (vfptr*)(*((void**)&b));PrintVtalbe(vtab1);PrintVtalbe(vtab2);return 0;
}

通过调试窗口，可以看到b对象只有继承下来的fun1和fun2而没有fun3