C++ 多态

比昨天多敲两行2026-03-25 16:26

一、多态的概念

多态：同一种行为，不同对象表现出不同形态。

C++ 多态分为两种：

  1. 静态多态（编译时多态）

    • 编译阶段就确定调用哪个函数
    • 典型代表：函数重载、函数模板

  2. 动态多态（运行时多态）

    • 运行阶段才根据指向的对象确定调用哪个函数
    • 典型代表：继承 + 虚函数 + 重写

生活例子：

  • 普通人买票：全价
  • 学生买票：半价
  • 军人买票：优先
  • 同一个 "买票" 行为，不同人结果不同 → 这就是多态。

二、多态的定义及实现

2.1 构成多态的两个必须条件

  1. 必须通过基类的指针或引用调用虚函数
  2. 被调用的函数必须是虚函数，且派生类完成了虚函数重写（覆盖）

两个条件缺一不可！

2.2 虚函数

成员函数 前面加 virtual 关键字，就是虚函数。

  • 只有类成员函数才能是虚函数
  • 普通函数 / 全局函数不能加 virtual
cpp 复制代码 
class Person
{
public:
    virtual void BuyTicket()
    {
        cout << "买票-全价" << endl;
    }
};

2.3 虚函数的重写（覆盖）

派生类中有一个和基类完全相同的虚函数：

  • 函数名相同
  • 参数列表相同
  • 返回(类型)值相同（协变例外）

就叫重写 / 覆盖。

cpp 复制代码 
class Person
{
public:
    virtual void BuyTicket() { cout << "全价" << endl; }
};

class Student : public Person
{
public:
    virtual void BuyTicket() { cout << "半价" << endl; }
};

重点 ：派生类不加 virtual 也能构成重写（因为虚属性会被继承），但写法不规范，考试常挖坑。

cpp 复制代码 
#include<iostream>
using namespace std;

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "全价" << endl;
	}
};

class Student :public Person
{
public:
	 void BuyTicket()//不写virtual也能构成重写
	{
		cout << "半价" << endl;
	}

};

int main()
{
	Person p;
	Student s;	
	p.BuyTicket();//全价
	s.BuyTicket();//半价
	return 0;
}

2.4 多态使用示例

cpp 复制代码 
class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "全价" << endl;
	}
};

class Student :public Person
{
public:
	 virtual void BuyTicket()
	{
		cout << "半价" << endl;
	}

};

void func(Person* ptr)
{
   // 多态调用：看指向的对象，不看指针类型
	ptr->BuyTicket();
}

int main()
{
	Person p;
	Student s;	
	func(&p);//全价
	func(&s);//半价
	return 0;
}

多态场景的⼀个选择题

以下程序输出结果是什么（B）

A: A->0 B:B->1 C:A->1 D:B->0 E:编译出错 F:以上都不正确

cpp 复制代码 
class A
{
public:
	virtual void func(int val = 1){cout << "A->" << val << endl;}
	virtual void test() { func();}
};

class B :public A
{
public:
	void func(int val = 0) { cout << "B->" << val << endl;}
};

int main()
{
	B* p = new B;
	p->test();
	return 0;
}

原因：

重写本质是重写虚函数的实现，实际缺省值还是基类的val=1。

2.6 虚函数重写的特殊情况

（1）协变（了解）

基类返回基类指针 / 引用

派生类返回派生类指针 / 引用

返回值不同，但仍构成重写，叫协变

cpp 复制代码 
class A{};
class B: public A {};

class Person
{
public:
	virtual A* BuyTicket()
	{
		cout << "全价" << endl;
		return nullptr;
	}
};

class Student :public Person
{
public:
	 virtual B* BuyTicket()
	{
		cout << "半价" << endl;
		return nullptr;
	}

};

void func(Person* ptr)
{
	ptr->BuyTicket();
}

int main()
{
	Person p;
	Student s;	
	func(&p);//全价
	func(&s);//半价
	return 0;
}
（2）析构函数的重写
  • 基类析构函数加 virtual
  • 派生类析构函数无论写不写 virtual，都构成重写

原因：编译器会把所有析构函数名都处理成 destructor()，所以名字其实是一样的。

为什么基类析构要写成虚函数？

避免内存泄漏！

cpp 复制代码 
class A
{
public:
    //如果没加virtual，就只执行~A（），而B类申请的资源没得到释放会内存泄漏
    virtual ~A() { cout << "~A()" << endl; }
};

class B : public A
{
public:
    ~B()
    {
        cout << "~B()" << endl;
        delete _p;
    }
protected:
    int* _p = new int[10];
};

int main()
{
    A* p2 = new B;
    delete p2;
    return 0;
}
  • 析构不是虚函数 → 只调用～A () → 内存泄漏
  • 析构是虚函数 → ~B () → ~A () → 正确释放

2.7 C++11：override & final

（1）override

强制检查是否完成重写，写错直接编译报错。

cpp 复制代码 
class Car
{
public:
	virtual void Drive(){}
};

class Benz :public Car
{
public:
	//写错成Drive也会报错
	virtual void Drive()override { cout << "舒适"<<endl; }
};

错误示范：

（2）final
  • 修饰函数：禁止重写
  • 修饰类：禁止继承
cpp 复制代码 
class Car
{
public:
    virtual void Drive() final {}
};

// 无法重写，编译报错
class Benz : public Car
{
    virtual void Drive() {}
};

2.8 重载 / 重写 / 隐藏 （重定义）对比

口诀：

  • 同一作用域、参数不同 → 重载
  • 不同作用域、虚函数、完全相同 → 重写
  • 不同作用域、不是重写、名字相同 → 隐藏

三、纯虚函数与抽象类

在虚函数的后⾯写上=0，则这个函数为纯虚函数，纯虚函数不需要定义实现(实现没啥意义因为要被 派⽣类重写，但是语法上可以实现)，只要声明即可。包含纯虚函数的类叫做抽象类，抽象类不能实例 化出对象，如果派⽣类继承后不重写纯虚函数，那么派⽣类也是抽象类。纯虚函数某种程度上强制了 派⽣类重写虚函数，因为不重写实例化不出对象。

3.1 纯虚函数

虚函数后面写 =0

cpp 复制代码 
virtual void Speak() = 0;

3.2 抽象类

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

特点：

  1. 不能实例化对象
  2. 派生类必须重写纯虚函数，否则派生类也是抽象类
cpp 复制代码 
class Animal
{
public:
    virtual void Speak() = 0; // 纯虚函数
};

class Dog : public Animal
{
public:
    virtual void Speak()
    {
        cout << "汪汪汪" << endl;
    }
};

int main()
{
    // Animal a; 错误！抽象类不能实例化
    Animal* p = new Dog;
    p->Speak();
    return 0;
}

意义：强制接口规范，必须重写。

四、多态的原理（底层硬核）

4.1 虚函数表指针（_vfptr）

只要类里有虚函数，对象中就会多一个指针：

_vfptr（虚函数表指针）

  • 占 4/8 字节（32/64 位）
  • 指向虚函数表（vftable）

下⾯编译为32位程序的运⾏结果是什么（D）

A. 编译报错 B.运⾏报错C.8 D.12

cpp 复制代码 
class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1" << endl;
	}
protected:
	int _a = 1;
	char _ch = 'x';
};

int main()
{
	Base b;
	cout << sizeof(b) << endl;
	return 0;
}

按照我们之前学的内存对齐，应该是int占4字节，char占1字节，然后对齐3个字节一共8字节。

但是实际运行结果是12字节。

因为除了_a和_ch两个成员外，还有一个_vfptr这个虚函数指针，_vfptr在32位平台下占4个字节。

⼀个含有虚函数的类中都⾄少都有⼀个虚函数表指针，因为⼀个类所有虚函数的地址要 被放到这个类对象的虚函数表中，虚函数表也简称虚表。

4.3 多态到底是怎么实现的？

满足多态条件后：

  1. 编译时：不确定函数地址
  2. 运行时：
    • 通过对象的 _vfptr 找到虚表
    • 在虚表里找到对应虚函数地址
    • 调用函数
cpp 复制代码 
class Person
{
public:
    virtual void BuyTicket()
    {
        cout << "买票全价" << endl;
    }
private:
    string _name;
};

class Student : public Person 
{
public:
    virtual void BuyTicket()
    {
        cout << "买票打折" << endl;
    }
private:
    string _id;
};

class Soldier : public Person 
{
public:
    virtual void BuyTicket()
    {
        cout << "买票优先" << endl;
    }
private:
    string _codename;
};

void Func(Person* ptr)
{
    // 这⾥可以看到虽然都是Person指针Ptr在调⽤BuyTicket 
    // 但是跟ptr没关系，⽽是由ptr指向的对象决定的。
    ptr->BuyTicket();
}

// 其次多态不仅仅发⽣在派⽣类对象之间，多个派⽣类继承基类，重写虚函数后
// 多态也会发⽣在多个派⽣类之间。
int main()
{
    Person ps;
    Student st;
    Soldier sr;
    Func(&ps);
    Func(&st);
    Func(&sr);
    return 0;
}

我们可以看见，同样是调用BuyTicket()，Person类型(基类)应该是调用Person内部的BuyTicket()但是Student或Soldier(子类)给Person赋值后，Person调用的却是对应类型(Student或Soldier)的BuyTicket()满⾜多态条件后，底层 不再是编译时通过调⽤对象确定函数的地址，⽽是运⾏时到指向的对象的虚表中确定对应的虚函数的 地址，这样就实现了指针或引⽤指向基类就调⽤基类的虚函数，指向派⽣类就调⽤派⽣类对应的虚函 数。ptr指向的Person对象，调⽤的是Person的虚函数；第⼆张图，ptr指向的Student对 象，调⽤的是Student的虚函数。

4.4 静态绑定 vs 动态绑定

  • 静态绑定：对不满⾜多态条件(指针或者引⽤+调⽤虚函数)的函数调⽤是在编译时绑定，也就是编译时确定调⽤ 函数的地址，叫做静态绑定。
  • 动态绑定：满⾜多态条件的函数调⽤是在运⾏时绑定，也就是在运⾏时到指向对象的虚函数表中找到调⽤函数 的地址，也就做动态绑定。

4.5 虚表和虚函数存在哪里？

1.基类对象的虚函数表中存放基类所有虚函数的地址。同类型的对象共⽤同⼀张虚表，不同类型的对 象各⾃有独⽴的虚表，所以基类和派⽣类有各⾃独⽴的虚表。

2.派⽣类由两部分构成，继承下来的基类和⾃⼰的成员，⼀般情况下，继承下来的基类中有虚函数表 指针，⾃⼰就不会再⽣成虚函数表指针。但是要注意的这⾥继承下来的基类部分虚函数表指针和基 类对象的虚函数表指针不是同⼀个，就像基类对象的成员和派⽣类对象中的基类对象成员也独⽴ 的。

3.派⽣类中重写的基类的虚函数，派⽣类的虚函数表中对应的虚函数就会被覆盖成派⽣类重写的虚函 数地址。

4.派⽣类的虚函数表中包含，(1)基类的虚函数地址，(2)派⽣类重写的虚函数地址完成覆盖，派⽣类 ⾃⼰的虚函数地址三个部分。

5.虚函数表本质是⼀个存虚函数指针的指针数组，⼀般情况这个数组最后⾯放了⼀个0x00000000标 记。(这个C++并没有进⾏规定，各个编译器⾃⾏定义的，vs系列编译器会再后⾯放个0x00000000 标记，g++系列编译不会放)

6.虚函数存在哪的？虚函数 和普通函数⼀样的，编译好后是⼀段指令，都是存在代码段的，只是虚函 数的地址⼜存到了虚表中。

7.虚函数表 存在哪的？这个问题严格说并没有标准答案C++标准并没有规定，vs下是存在代码段/常量区。

五、全文总结

  1. 多态 =继承 + 虚函数 + 重写 + 基类指针 / 引用
  2. 重写要求：函数名、参数、返回值相同（协变例外）
  3. 析构函数建议写成虚函数，防止内存泄漏
  4. override 检查重写，final 禁止重写 / 继承
  5. 纯虚函数用于抽象类，强制接口规范
  6. 多态底层靠 _vfptr + 虚表 实现
  7. 普通调用是静态绑定 ，多态调用是动态绑定
相关推荐
、BeYourself2 小时前
Scala 字面量
开发语言·后端·scala
Amumu121382 小时前
JS：ES6~ES11基础语法(二)
开发语言·前端·javascript
是娇娇公主~2 小时前
C++ 多态机制与虚函数实现原理
c语言·c++
Amumu121382 小时前
Js：ES6~ES11基础语法(一)
开发语言·前端·javascript
m0_569881472 小时前
跨语言调用C++接口
开发语言·c++·算法
zdl6862 小时前
搭建Golang gRPC环境：protoc、protoc-gen-go 和 protoc-gen-go-grpc 工具安装教程
开发语言·后端·golang
LilySesy2 小时前
【与AI+】英语day1——ABAP基础与数据类型
开发语言·ai·sap·abap
你不是我我2 小时前
【Java 开发日记】我们来说一下 b+ 树与 b 树的区别
java·开发语言
2501_924952692 小时前
C++中的过滤器模式
开发语言·c++·算法
热门推荐
01GitHub 镜像站点02Qwen3.5 开源全解析：从 0.8B 到 397B，代际升级 + 全场景选型指南03围棋-html版本04小黑课堂计算机二级WPSoffice题库软件下载安装教程（2026年3月最新版）05OpenClaw 使用和管理 MCP 完全指南06班级宠物园部署指南07UV安装并设置国内源08“wsl --install -d Ubuntu-22.04”下载慢，中国地区离线安装 Ubuntu 22.04 WSL方法（亲测2025年5月6日）09让 Trae IDE 智能体 “读懂”文档 Excel+PDF+DOCX ：mcp-documents-reader 工具使用指南10OpenClaw Control UI安全上下文访问配置