当前位置：首页 > news >正文

C++面向对象三大特征之一 ——(多态)

news 来源：原创 2025/7/16 5:20:13

C++面向对象三大特征之一 ——多态

一. 多态的概念
二. 多态的定义及实现
- 2.1多态的构成条件
- 2.2 虚函数
- 2.3虚函数的重写
- - 虚函数重写的两个例外：
- 2.4 C++11 override 和 final
- 2.5 重载、覆盖(重写)、隐藏(重定义)的对比
三. 抽象类
- 接口继承和实现继承
四.多态的原理
- 4.1虚函数表
虚函数表存储在内存中的哪里
- 4.2多态的原理
- 4.3 动态绑定与静态绑定
练题

一. 多态的概念

多态的概念：同一个方法或操作在不同的对象上可以有不同的表现或实现方式。简而言之，多态允许不同的对象以相同的方式响应相同的消息（方法调用），但是它们的行为却可能不同。多态让相同的接口具有不同的实现，提升了代码的复用性和扩展性。
例如：动物的叫声,狗是汪汪,猫是喵喵,同样都是叫声,发出的声音却不同。

二. 多态的定义及实现

2.1多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为
构成多态有两个条件：

必须通过基类的指针或者引用调用虚函数
被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

虚函数构成重写的要求：函数名，返回值，参数相同。

如下代码：

#include<iostream>
using namespace std;class Animal
{
public:virtual void sound(){cout << "sound" << endl;}
private:
};class Dog :public Animal
{
public:virtual void sound(){cout << "旺旺" << endl;}
private:string name = "";
};class Cat :public Animal
{
public:virtual void sound(){cout << "喵喵" << endl;}
private:string name = "";
};void AnimalSound(Animal& anm)
{anm.sound();
}int main()
{Animal a;Dog d;Cat c;AnimalSound(a);AnimalSound(d);AnimalSound(c);return 0;
}

输出结果：
在这里插入图片描述

2.2 虚函数

被 virtual 修饰的成员函数就是虚函数

class Animal
{
public:virtual void sound(){cout << "sound" << endl;}
};

2.3虚函数的重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

class Animal
{
public:virtual void sound(){cout << "sound" << endl;}
private:
};class Dog :public Animal
{
public:virtual void sound(){cout << "旺旺" << endl;}
};void AnimalSound(Animal& anm)
{anm.sound();
}int main()
{Animal a;Dog d;AnimalSound(a);AnimalSound(d);return 0;
}

这样写构成多态，AnimalSound函数可以输出对应动物的叫声。

但我们依然可以使函数只输出 sound（这是动物的叫声，看函数的定义），那就是指定类域，因为重写属于特殊的重定义（隐藏）。

虚函数重写的两个例外：

协变：虚函数的返回值可以不同，但返回值的类型必须是父类与子类的关系

class A {};
class B : public A {};class Animal
{
public:virtual A* f(){cout << "virtual A* f()" << endl;return new A;}
};class Dog :public Animal
{
public:virtual B* f(){cout << "virtual B* f()" << endl;return new B;}
};void fun(Animal& anm)
{anm.f();
}int main()
{Animal a;Dog d;fun(a);fun(d);return 0;
}

在这里插入图片描述

析构函数的重写(基类与派生类析构函数的名字不同)

class Animal
{
public:~Animal(){cout << "~Animal()" << endl;}
};class Dog :public Animal
{
public:~Dog(){cout << "~Dog()" << endl;}
};int main()
{Animal* panm = new Dog;delete panm;return 0;
}

这段程序不加 virtual 会导致内存泄漏
在这里插入图片描述
没有 virtual 修饰的析构函数它不构成多态，new申请的是 Dog 类，delete释放时只释放了Dog中 Animal部分

之前继承章节说过，继承的析构函数会先释放自己的那一部分，再调用父类的析构，释放父类的那一部分部分（且父类的析构我们不能显示的调用，必须由编译器自己调用）
所以我们现在的目的是让析构调到Dog（子类）里去。

在这里插入图片描述

上面说过构成多态的条件是：构成重写；必须是基类的指针或引用调用，重写的条件又是：函数名，返回值，参数相同。

父类和子类的函数名很明显不相同，但它们加上virtual后构成多态。
原因：为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

加上 virtual 后可以正确调用析构函数。
在这里插入图片描述

2.4 C++11 override 和 final

C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

override 检查函数是否被重写，如果没有重写则会报错

class Animal
{
public:void sound(){cout << "sound" << endl;}
};class Dog :public Animal
{
public:virtual void sound() override{cout << "旺旺" << endl;}
};

在这里插入图片描述
final 修饰的函数不能被重写，如果重写了就会报错

在这里插入图片描述
这样设计的意义是上面呢？
既然写了 virtual 那就说明函数可能会被重写，但又写了 final 不让函数被重写。
如下使用场景：

class Animal {
public:virtual void sound() {std::cout << "Animal sound" << std::endl;}
};class Dog : public Animal 
{
public:void sound() override final{std::cout << "Bark" << std::endl;}
};class Bulldog : public Dog 
{
public:// 这行会报错，因为 `sound` 在 Dog 中是 final，不能在 Bulldog 中重写void sound() override {std::cout << "Loud Bark" << std::endl;}
};

在这里插入图片描述

final 修饰的类不可以被继承

class Animal final
{
public:virtual void sound() {std::cout << "Animal sound" << std::endl;}
};class Dog : public Animal 
{
public:void sound() override {std::cout << "Bark" << std::endl;}
};

在这里插入图片描述

2.5 重载、覆盖(重写)、隐藏(重定义)的对比

在这里插入图片描述

三. 抽象类

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

class Animal
{
public:virtual void sound() = 0{cout << "sound" << endl;}
};class Dog :public Animal
{
public:virtual void sound(){cout << "旺旺" << endl;}
};void AnimalSound(Animal& anm)
{anm.sound();
}int main()
{Animal a;Dog d;AnimalSound(d);return 0;
}

在这里插入图片描述
因为Animal 包含纯虚函数，所以它是抽象类，无法实例化出对象

接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

四.多态的原理

4.1虚函数表

先计算下面程序的输出结果

class A
{
public:virtual void fun1(){}virtual void fun2(){}
private:int _a;
};class B
{
public:virtual void fun3(){}private:int _b;int _c;
};int main()
{cout << sizeof(A) << endl;cout << sizeof(B) << endl;return 0;
}

在这里插入图片描述

输出结果:
8
12
发现两个类都多了四字节的大小
实际上是因为虚函数导致多了四个字节的大小
当一个类中有虚函数时,这个类就会生成一个指针,指针向虚函数表,虚函数表中存放的是这个类中每个虚函数的地址。所以sizeof计算大小时会多出4个字节(多出一个指针的大小)
虚函数表中存的是虚函数的地址,那虚函数表本身是一个函数指针数组
类中自动生成的指针指向虚函数表,它的类型是函数指针数组指针,
下面画图+代码讲解

有如下代码:

B类继承A类
B类中重写了 fun1()函数class A
{
public:virtual void fun1(){}virtual void fun2(){}void fun3(){}private:int _a = 0;
};class B:public A
{
public:virtual void fun1(){}private:int _b = 0;int _c = 0;
};int main()
{A a;B b;return 0;
}

通过调试窗口查看,自动生成的指向虚函数表的指针:_vfptr
在这里插入图片描述

先看a对象：这里的 _vfptr 就是自动生成的指针,它指向了虚函数表,虚函数表中有两个元素(这两个元素是指针),指针分别指向虚函数 fun1() ,fun2() , fun3() 不是虚函数，所以不在虚函数表中。

再看b对象：b中包含了a对象，b中的a的 _vfptr 中也有两个元素，第一个元素是B类中重写后fun1() 的地址，第二个元素是 A类中fun2() 的地址，所以看到上图中的a对象的 _vfptr 的第二个元素与 b对象中A类部分的 _vfptr 的第二个元素的地址相同。

再声明一个 aa 对象，如下：

int main()
{A a;A aa;B b;return 0;
}

在这里插入图片描述
这里的 a 与 aa 的虚表的地址相同。证明了用同一个类声明出来的所有对象用的都是同一个虚表

总结一下派生类的虚表生成：

先将基类中的虚表内容拷贝一份到派生类虚表中
如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数
派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

虚函数表存储在内存中的哪里

class A
{
public:virtual void fun1(){cout << "a::virtual void fun1()" << endl;}virtual void fun2(){}void fun3(){cout << "a::void fun3()" << endl;}private:int _a = 0;
};class B:public A
{
public:virtual void fun1(){cout << "b::virtual void fun1()" << endl;}private:int _b = 0;int _c = 0;
};void fun(A& ra)
{//动态绑定ra.fun1();//静态绑定ra.fun3();
}int main()
{int i = 0;static int j = 1;int* p1 = new int;const char* p2 = "xxxxxxxx";printf("栈:%p\n", &i);printf("静态区:%p\n", &j);printf("堆:%p\n", p1);printf("常量区:%p\n", p2);A a;B b;printf("A虚表地址:%p\n", *((int*)&a));printf("B虚表地址:%p\n", *((int*)&b));printf("A对象地址:%p\n", &a);printf("B对象地址:%p\n", &b);return 0;
}

在这里插入图片描述
虚函数表的地址与常量区接近，所以虚函数表和普通函数，虚函数一样都存在常量区（代码段），虚函数表在编译阶段生成

4.2多态的原理

class A
{
public:virtual void fun1(){cout << "A::virtual void fun1()" << endl;}virtual void fun2(){}void fun3(){cout << "A::void fun3()" << endl;}private:int _a = 0;
};class B:public A
{
public:virtual void fun1(){cout << "B::virtual void fun1()" << endl;}private:int _b = 0;int _c = 0;
};void fun(A& ra)
{ra.fun1();ra.fun3();
}int main()
{A a;B b;fun(a);fun(b);return 0;
}

输出结果
在这里插入图片描述
b是如何调用到它自己类中的函数的呢？

就是上面讲到的虚函数表。
在这里插入图片描述
下图中的引用可以理解为，引用的是子类中的父类部分，它会把虚函数表带过去。（指针也是同理）

由上图可以看出
多态的实现就是由虚函数表来完成的。
通过指针或引用来调用虚函数：

通过对象直接调用虚函数时，C++会直接调用对象的相应函数版本，不会发生多态。
只有当通过基类的指针或引用调用虚函数时，C++才能实现动态绑定（即运行时多态），从而根据对象的实际类型调用正确的虚函数版本。

4.3 动态绑定与静态绑定

动态绑定：运行时绑定，虚函数。
静态绑定：编译时绑定，普通函数。
在这里插入图片描述
通过汇编代码，可以更清楚的看到虚函数是在运行时绑定的。

静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态
比如：函数重载
动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。
对象访问普通函数快还是虚函数更快？答：首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。

练题

下面代码输出的是什么

class A 
{
public:virtual void func(int val = 1) {  // 默认参数是 1std::cout << "A->" << val << std::endl;}virtual void test() {func();  // 默认参数 1}
};class B : public A 
{
public:void func(int val = 0) override {  // 默认参数是 0std::cout << "B->" << val << std::endl;}
};int main() 
{B* p = new B;p->test();  // 调用 A::test()return 0;
}

解析：
p是指向B对象的指针，因为B继承了A，B中没有test()，就会调到A中的test()
test()，中又调用func()，func()函数有virtual修饰构成多态。
所以输出是 B->0 ？？？
答案是B->1
在这里插入图片描述
因为C++中的重写，它只重写函数体，不会重写函数头。
所以是A中的函数头 virtual void func(int val = 1)
B中的函数体
{
std::cout << “B->” << val << std::endl;
}

C++面向对象三大特征之一 ——多态

一. 多态的概念

二. 多态的定义及实现

2.1多态的构成条件

2.2 虚函数

2.3虚函数的重写

虚函数重写的两个例外：

2.4 C++11 override 和 final

2.5 重载、覆盖(重写)、隐藏(重定义)的对比

三. 抽象类

接口继承和实现继承

四.多态的原理

4.1虚函数表

虚函数表存储在内存中的哪里

4.2多态的原理

4.3 动态绑定与静态绑定

练题

相关文章：