【C++进阶】多态，坑很多，面试常考！！！

王璐WL2026-05-23 8:40

​

文章目录

  • [1. 多态的概念](#1. 多态的概念)
  • [2. 多态的定义及实现](#2. 多态的定义及实现)
    • [2.1 多态的构成条件](#2.1 多态的构成条件)
    • [2.2 虚函数](#2.2 虚函数)
    • [2.3 虚函数的重写/覆盖](#2.3 虚函数的重写/覆盖)
    • [2.4 多态场景的一个选择题](#2.4 多态场景的一个选择题)
    • [2.5 虚函数重写的一些其他问题](#2.5 虚函数重写的一些其他问题)
      • [2.5.1 协变(了解)](#2.5.1 协变(了解))
      • [2.6.2 析构函数的重写](#2.6.2 析构函数的重写)
    • [2.6 override和final关键字](#2.6 override和final关键字)
    • [2.7 重载/重写/隐藏的对比](#2.7 重载/重写/隐藏的对比)
  • [3. 纯虚函数和抽象类](#3. 纯虚函数和抽象类)
  • [4. 多态的原理（重点）](#4. 多态的原理（重点）)
    • [4.1 虚函数表指针](#4.1 虚函数表指针)
    • [4.2 多态是如何实现的](#4.2 多态是如何实现的)
    • [4.3 动态绑定与静态绑定](#4.3 动态绑定与静态绑定)
    • [4.4 虚函数表（概念多多）](#4.4 虚函数表（概念多多）)

1. 多态的概念

多态(polymorphism)通俗来说，就是多种形态。多态分为编译时多态(静态多态)和运行时多态(动态多态)，这里我们重点讲运行时多态。

编译时多态(静态多态)主要就是我们前面讲的函数重载和函数模板 ，它们通过传不同类型的参数调用不同的函数，达到多种形态。之所以叫编译时多态，是因为实参传给形参的参数匹配是在编译时完成的，我们把编译时一般归为静态，运行时归为动态。

运行时多态，具体点就是调用函数时，传不同的对象就会完成不同的行为，就达到多种形态。比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是优惠买票(5折或75折)；军人买票时是优先买票。再比如，同样是动物叫的一个行为(函数)，传猫对象过去，就是"喵"，传狗对象过去，就是"汪汪"。

2. 多态的定义及实现

2.1 多态的构成条件

多态是一个继承关系下的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person，Person对象买票全价，Student对象优惠买票。

实现多态还有两个必须重要条件：

• 必须是基类的指针或者引⽤调⽤虚函数

• 被调⽤的函数必须是虚函数，并且完成了虚函数重写/覆盖。

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

class Animal {
public:
    virtual void sound() {      // 必须是虚函数
        cout << "动物发声" << endl;
    }
};

class Dog : public Animal {
public:
    void sound() override {     // 完成了重写（                                    
        cout << "汪汪" << endl;
    }
};

class Cat : public Animal {
public:
    void sound() override {
        cout << "喵喵" << endl;
    }
};

int main() {
    // 基类指针指向子类对象
    Animal* p1 = new Dog();
    Animal* p2 = new Cat();

    p1->sound();   // 输出 "汪汪"（动态绑定）
    p2->sound();   // 输出 "喵喵"

    // 基类引用
    Cat c;
    Animal& r = c;
    r.sound();     // 输出 "喵喵"

    delete p1; delete p2;
    return 0;
}

2.2 虚函数

类成员函数前面加virtual修饰，那么这个成员函数被称为虚函数。注意非成员函数不能加virtual修饰。

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

2.3 虚函数的重写/覆盖

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

注意：在重写基类虚函数时，**派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来了，在派生类依旧保持虚函数属性)，但是该种写法不是很规范，不建议这样使用。**不过在考试选择题中，经常会故意埋这个坑，让你判断是否构成多态。

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

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

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

int main() {
    Person ps;
    Student st;
    Func(&ps);
    Func(&st);
    return 0;
}
cpp 复制代码 
class Animal {
public:
    virtual void talk() const {}
};

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

class Cat : public Animal {
public:
    virtual void talk() const {
        std::cout << "(>^ω^)喵" << std::endl;
    }
};

void letsHear(const Animal& animal) {
    animal.talk();
}

int main() {
    Cat cat;
    Dog dog;
    letsHear(cat);
    letsHear(dog);
    return 0;
}

2.4 多态场景的一个选择题

以下程序输出结果是什么？

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

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

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

答案：B->1 （因为缺省参数使用的是基类的，而函数体是派生类的）

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

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

int main() {
    B* p = new B;   // 指针类型就是派生类 B*
	p->func();      // 直接调用 B::fun
    return 0;
}

p->func() 中指针是 B* 而不是 A*，所以不构成多态。

所以选D

2.5 虚函数重写的一些其他问题

2.5.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 ps;
    Student st;
    Func(&ps);
    Func(&st);
    return 0;
}

2.6.2 析构函数的重写

++基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写。虽然基类与派生类析构函数名字不同，看起来不符合重写的规则，实际上编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor，所以基类的析构函数加了virtual修饰，派生类的析构函数就构成重写。++

下面的代码可以看到，如果~ A()不加virtual，那么delete p2时只调用A的析构函数，没有调用B的析构函数，就会导致内存泄漏问题，因为~B()中在释放资源。

注意：这个问题面试中经常考察，一定要结合类似下面的样例才能讲清楚，为什么基类中的析构函数建议设计为虚函数。

cpp 复制代码 
class A {
public:
    virtual ~A() {
        cout << "~A()" << endl;
    }
};

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

int main() {    
    A* p1 = new B;
    delete p1;
    return 0;
}

A的析构函数不加virtual，只会调用 A:: ~ A()，不会调用 B::~B()。

B 中 _p 指向的 int[10] 内存永远不会被 delete，造成内存泄漏。

2.6 override和final关键字

C++11提供了override，可以帮助用户检测是否重写（加在派生类）。如果我们不想让派生类重写这个虚函数，那么可以用final去修饰（加在基类）。

cpp 复制代码 
// error C3668: "Benz::Drive": 包含重写说明符"override"的方法没有重写任何基类方法
class Car {
public:
    virtual void D() {}
};

class Benz : public Car {
public:
    virtual void Drive() override { cout << "Benz-舒适" << endl; }
};

int main() {
    return 0;
}
cpp 复制代码 
// error C3248: "Car::Drive": 声明为"final"的函数无法被"Benz::Drive"重写
class Car {
public:
    virtual void Drive() final {}
};

class Benz : public Car {
public:
    virtual void Drive() { cout << "Benz-舒适" << endl; }
};

int main() {
    return 0;
}

2.7 重载/重写/隐藏的对比

函数间关系

3. 纯虚函数和抽象类

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

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

class Benz : public Car {
public:
    virtual void Drive() {
        cout << "Benz-舒适" << endl;
    }
};

class BMW : public Car {
public:
    virtual void Drive() {
        cout << "BMW-操控" << endl;
    }
};

int main() {
    // 编译报错：error C2259: "Car": 无法实例化抽象类
    // Car car;

    Car* pBenz = new Benz;
    pBenz->Drive();

    Car* pBMW = new BMW;
    pBMW->Drive();

    return 0;
}

4. 多态的原理（重点）

4.1 虚函数表指针

下面编译为32位程序的运行结果是什么？

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

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

运行结果：12 bytes，除了_b和_ch成员，还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)。对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为一个类所有虚函数的地址要被放到这个类对象的虚函数表中，虚函数表也简称虚表 。

4.2 多态是如何实现的

从底层的角度，Func函数中ptr->BuyTicket()，是如何做到ptr指向Person对象调用Person::BuyTicket，指向Student对象调用Student::BuyTicket的呢？通过下图我们可以看到，满足多态条件后，底层不再是编译时通过调用对象确定函数的地址，而是运行时到指向的对象的虚表中确定对应的虚函数的地址，这样就实现了指针或引用指向基类就调用基类的虚函数，指向派生类就调用派生类对应的虚函数。

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;
};


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

int main() {
    Person ps;
    Student st;
    Soldier sr;
    Func(&ps);
    Func(&st);
    return 0;
}

4.3 动态绑定与静态绑定

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

• 满⾜多态条件的函数调⽤是在运⾏时 绑定，也就是在运⾏时到指向对象的虚函数表中找到调⽤函数的地址 ，也就做动态绑定。

cpp 复制代码 
// ptr是指针+BuyTicket是虚函数满足多态条件。
// 这里就是动态绑定，编译在运行时到ptr指向对象的虚函数表中确定调用函数地址
ptr->BuyTicket();

// BuyTicket不是虚函数，不满足多态条件。
// 这里就是静态绑定，编译器直接确定调用函数地址
ptr->BuyTicket();

4.4 虚函数表（概念多多）

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

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

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

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

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

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

• 虚函数表存在哪的？这个问题严格说并没有标准答案C++标准并没有规定，我们写下⾯的代码可以对⽐验证⼀下。vs下是存在代码段(常量区)

这⾥Derive中没有看到func3函数，这个vs监视窗⼝看不到，可以通过内存窗⼝查看

、

cpp 复制代码 
class Base {
public:
    virtual void func1() { cout << "Base::func1" << endl; }
    virtual void func2() { cout << "Base::func2" << endl; }
    void func5() { cout << "Base::func5" << endl; }
protected:
    int a = 1;
};

class Derive : public Base {
public:
    // 重写基类的func1
    virtual void func1() { cout << "Derive::func1" << endl; }
    virtual void func3() { cout << "Derive::func3" << endl; }
    void func4() { cout << "Derive::func4" << endl; }
protected:
    int b = 2;
};

int main() {
    Base b;
    Derive d;
    return 0;
}
cpp 复制代码 
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);

    Base b;
    Derive d;
    Base* p3 = &b;
    Derive* p4 = &d;

    printf("Person虚表地址:%p\n", *(int*)p3);
    printf("Student虚表地址:%p\n", *(int*)p4);
    printf("虚函数地址:%p\n", &Base::func1);
    printf("普通函数地址:%p\n", &Base::func5);

    return 0;
}

运行结果示例：

栈:010FF954

静态区:0071D000

堆:0126D740

常量区:0071ABA4

Person虚表地址:0071AB44

Student虚表地址:0071AB84

虚函数地址:00711488

普通函数地址:007114BF

虚函数和常量区离得很近

​

相关推荐
运筹vivo@1 小时前
33. 搜索旋转排序数组(leetcode每日一题)
c++·算法
JAVA社区1 小时前
Java进阶全套教程（八）—— Docker超详细实战详解
java·运维·开发语言·docker·容器·面试·职场和发展
todaycode1 小时前
Vue + CPP项目
javascript·c++·vue.js
玖釉-1 小时前
Slang 和 HLSL 的区别与用法详解：现代图形渲染中的两种 Shader 编程语言
c++·算法·图形渲染
TechPioneer_lp1 小时前
就业指导｜中九非科班毕业，华为 OD 做 Java 后端想转 C++，能找到深度学习挂钩的岗工作吗？
java·c++·华为od·华为·就业指导·校招指导
枕星而眠1 小时前
C++ String类精讲：从基础用法到进阶底层原理
开发语言·c++·后端·学习方法
江屿风1 小时前
【C++笔记】模板初阶流食般投喂
开发语言·c++·笔记
Shadow（⊙ｏ⊙）1 小时前
qt信号和槽链接的接入与断开
开发语言·前端·c++·qt·学习
肩上风骋1 小时前
C++基本知识点积累之d指针，invokemethod函数（一）
开发语言·c++·d指针·invokemethod（）
热门推荐
01GitHub 镜像站点02Codex 接入 DeepSeek API 完整配置文档03装上就回不去了：CodeGraph 让 AI 编程效率飙升 92%，它到底做了什么？04【踩坑记录 | 第一篇】微软商店无法使用时，如何手动安装 OpenAI Codex？附`.msix`文件系统错误解决方法05【AI】2026 年具身智能模型和世界模型总结06裂开！ChatGPT 居然开始要手机号验证，附详细解决方法07CC-Switch & Claude 基于 Linux 服务器安装使用指南08几个好用的ip纯净度检测网站09用了半年 OpenRouter，我换到了 Ofox.ai — 两个 AI API 聚合平台的真实对比10codex app每次打开重连5次Reconnecting问题解决