企业官网建设流程全解析

你是不是也遇到过这种情况：简历上写着“熟练掌握C++”，结果嵌入式面试官一句“那你讲讲虚函数表放在哪、析构函数为什么必须是虚的、vector里放对象什么时候调拷贝构造”，当场就卡壳了。

这不是你学得不够，而是C++在嵌入式这个方向的老问题——项目里写了很多C，C++面试题却考得特别刁钻。尤其是虚函数、多态、拷贝构造这三座大山，几乎是每个嵌入式C++岗位的必考区。我面试过不少做单片机、Linux驱动、RTOS开发的候选人，发现能把这三块真正讲透的人真的不多，大多数人停留在“背定义”的程度，一问到底层机制、内存布局、性能开销就露馅了。

这篇我就站在面试官的角度，把虚函数、多态、拷贝构造这三个方向掰开揉碎，结合嵌入式场景讲清楚：底层是怎么实现的、面试官到底想听什么、你怎么回答才能不被连环追问打趴下。内容偏实战，适合正在准备嵌入式C++面试的朋友，也适合想补一补面向对象底层知识的开发者。

1. 先搞懂面试官为什么盯上这三个点

1.1 C++在嵌入式领域的真实分量

嵌入式开发这些年C++的占比越来越高，M7、A系列芯片跑Linux加Qt、RT-Thread上用C++写组件、各种传感器驱动和协议栈也用C++封装，已经不是新鲜事。但说实话，很多嵌入式项目的核心底层还是C，C++更多是出现在上层业务逻辑、中间件、SDK封装和工具链里。

这就造成一个很尴尬的局面：你可以用C写一辈子驱动，但面试官问你C++，你躲不掉。因为现在的嵌入式岗位几乎都用“C/C++”统一标注，而且C++的能力能反映一个人的抽象思维能力、资源管理水平和对编译器机制的熟悉程度。面试官不是要考倒你，而是想通过这三个基础概念，快速判断你写代码的层次。

拿我们组招聘来看，嵌入式C++岗位的面试题基本有三板斧：虚函数（问底层机制）、多态（问设计思路）、拷贝构造（问内存管理意识）。这三板斧过了，候选人的C++功底基本就有数了。

1.2 换位思考：面试官想通过这三个考点验证什么

先给大家透个底，面试官问虚函数、多态、拷贝构造，并不是单纯考背诵，而是层层递进地验证三种能力。

第一层是验证你对底层机制的理解。虚函数问的是vptr和vtable的布局、虚函数表和类成员变量的存放位置、编译器和链接器是怎么协作的。能讲清楚这层，说明你对C++对象模型不是停留在语法层面。

第二层是验证你的架构设计能力。多态问的是抽象和封装，面试官会假设一个传感器系统或者外设驱动场景，看你能不能设计出一个易于扩展的驱动框架。能做对，说明你具备面向对象的思想，而不只是会写class。

第三层是验证你的资源管理意识。拷贝构造问的是深拷贝、浅拷贝、资源所有权、生命周期管理。嵌入式环境里内存资源尤其宝贵，拷贝构造写不好，轻则内存泄漏，重则引起重复释放导致系统崩溃。

说白了，面试官是在通过这三个问题，模拟你是不是一个能在资源受限环境下写出健壮代码的人。明白了这个逻辑，你就知道往哪个方向去准备了。

2. 虚函数：从vtable到面试官的“一票否决题”

2.1 虚函数的底层实现，讲不清就别谈后面

虚函数的底层机制是嵌入式C++面试里我最常问的，因为这是一个分水岭。能把虚函数讲明白，说明你对程序的内存布局有感觉；讲不明白，后面基本就不用聊了。

先看一个最简单的例子：

#include <cstdint> #include <cstdio> class Base { public: virtual void func() { printf("Base::func\n"); } virtual void func2() { printf("Base::func2\n"); } void normal() { printf("Base::normal\n"); } int m_a = 1; }; class Derived : public Base { public: void func() override { printf("Derived::func\n"); } int m_b = 2; }; int main() { Base b; Derived d; printf("sizeof(Base) = %zu\n", sizeof(Base)); // 8 printf("sizeof(Derived) = %zu\n", sizeof(Derived)); // 12 return 0; }

在64位机器上，Base的大小是16字节，不是4字节——多出来一个指针大小的空间，这个指针就是vptr（虚函数表指针）。它指向一个属于Base类的虚函数表vtbl，表里面按声明顺序存着func和func2的函数地址。Derived重写了func，所以它的vtbl里第一个槽位就被替换成了Derived::func的地址。

很多人以为vtable是每个对象一份，这是错的。每个对象只保存一个vptr指针，vtable是每个类一份，在编译阶段生成，存放在程序的只读数据段（rodata）里。同一个类的所有对象共享同一个vtable，这也是为什么带虚函数的对象只多出vptr的开销而不是整个表。

面试时我一般接着追问：“构造函数里面调用虚函数会发生什么？”这个问题很有意思。Base类的构造函数执行时，vptr被初始化指向Base的vtable，所以即使你写的是this->func()，调用的也是Base版本的func。等Derived的构造函数开始执行，vptr才会被更新指向Derived的vtable。也就是说，构造期间虚函数不会表现出多态，这是C++标准明确规定的行为。回答到这一层，基本就过关了。

2.2 面试中高频追问：析构函数调虚函数会怎样

析构函数里调虚函数也是经典考点，背后的逻辑和构造函数类似，但方向相反。当Derived对象被析构时，先执行Derived的析构函数体，然后执行基类的析构函数体。进入Base析构函数后，vptr已经被重设为指向Base的vtable，此时调用虚函数，只会命中Base自己的版本。

这个机制背后其实有个工程原因：析构过程中，派生类成员已经先一步被销毁了，如果此时还能调用到派生类重写的虚函数，而这个函数访问了那些已经被销毁的成员，就会产生未定义行为。所以C++用“vptr随构造/析构过程逐步更新”的方式，从机制上规避了这个问题。

不过面试中我更关注候选人的工程直觉。析构函数里调虚函数虽然安全，但几乎总是代码坏味道。比如一个驱动框架里，基类析构函数里写了个虚函数close，意图是让它调用派生类的关闭逻辑，结果因为上面的机制，根本不会生效。正确做法是在析构函数里直接写死关闭步骤，或者用模板方法模式把清理逻辑放在非虚的公共接口里，让这个接口去调虚函数（在对象完整状态下调用）。

2.3 嵌入式场景追问：虚函数的性能开销到底多大

嵌入式的面试官不会只满足于“知道vptr”，尤其对于跑在MCU上的C++，性能问题永远是绕不开的话题。有一次面一个做传感器的候选人，他讲了一堆虚函数怎么用，我问他：“你在一个1ms中断里会调虚函数吗？”他愣了一下。

虚函数的性能开销主要有两块。第一块是间接跳转。普通函数调用是编译期确定的直接地址跳转，虚函数是运行时通过vptr寻址vtable再取函数指针，多了一次内存访问和一次间接跳转。第二块是内联失效。虚函数一般不能被内联（编译器在少数情况下通过devirtualization优化后可能内联，但大多数场景内联不了），对于高频小函数，内联失效带来的性能损失可能比间接跳转本身还大。

内存开销上也不可忽略。带虚函数的类，每个对象多一个vptr指针。如果一个对象的数量很大，比如内存池里的几千个小对象，多出来的指针开销就会非常可观。vtable本身在rodata区，一个类多一张表，表里每一项是一个函数指针，类多的时候Flash占用也会增加。

所以我面试时更欣赏能说出“虚函数在热路径、中断上下文、内存受限场合要慎用”的候选人，这比单纯背vtable机制更有价值。如果你能在回答里主动提到“为了确定性时间，我会考虑用静态多态（模板）替代动态多态"，面试官心里给你的分一定不低。

2.4 虚函数相关的设计坑：构造函数漏掉虚析构

虚函数相关的另一个高频考点是虚析构，这个在嵌入式C++开发里几乎是必踩的坑。看下面这段代码：

class Base { public: virtual ~Base() = default; }; class Derived : public Base { public: ~Derived() override { printf("release device resource\n"); } };

如果Base的析构函数没有virtual，那么用Base* p = new Derived()之后执行delete p，C++标准只保证调用Base的析构函数，Derived的析构函数不会被调用，派生类持有的资源（DMA缓冲区、GPIO句柄、动态内存）就全部泄漏了。这个损失在PC上可能不明显，但嵌入式上GPIO没释放、DMA没有停止、中断没关闭，整个系统状态就完全不对了。

这里要注意，虚析构的写法在C++11以后建议用virtual ~Base() = default;，而不是写一对空花括号，这个细节也经常被用来考察候选人对现代C++规范的熟悉程度。另外如果类的设计目标是当作final类使用，那可以不虚析构，但要保证没人通过基类指针删除它，工程上一般建议：所有带虚函数的类，都配一个虚析构，这是铁律。

3. 多态：别只会背“封装继承多态”

3.1 静态多态和动态多态的区别

很多人在面试时说“多态就是通过基类指针调用派生类的函数”，这句话只对了一半。多态在C++里其实有两类：编译期的静态多态和运行期的动态多态。

静态多态包括函数重载、运算符重载和模板。它的特点是编译期就确定调用哪个函数，没有运行时开销，缺点是类型必须在编译期确定。动态多态就是基类指针或引用调虚函数，基于vtable在运行期分发，灵活但有一定开销。

在嵌入式开发里，我见过太多人一提到多态就只想到虚函数，实际上嵌入式软件里用得最多的反而是模板，也就是静态多态。举个例子，一个数据采集系统需要支持SPI、I2C、UART三种总线上的传感器，用模板可以把数据帧解析、校验、转发的公共逻辑抽出来，业务代码里换总线时只需改类型声明，不需要改算法代码。更关键的是，模板在编译期就展开了，不会引入vptr，性能和内存占用都更可控。

面试时可以这样总结：“静态多态适合性能敏感的场景，动态多态适合运行期扩展性要求高的场景，嵌入式工程里二者会混合使用。”这种回答会让面试官觉得你有全局视角。

3.2 向上转型与类型安全

多态的核心本质是向上转型后仍能调用到派生类的行为。C++里向上转型有两个层次的理解。

第一层是安全转型。基类指针或引用指向派生类对象时，地址在数值上不变还是偏移，取决于类的内存布局。假如派生类有多个基类（多重继承），转型时指针值会发生偏移，这里面牵扯到调整this指针的复杂机制。单继承的情况，基类指针和派生类对象首地址一致；多基类时，指向第二个及以后基类的指针会比派生类对象地址往后偏移。

更值得注意的坑是切片。假如写了一个函数void show(Base b)，参数按值传Base，你再传一个Derived进去，编译器会把派生类对象的Base部分复制出来，派生类部分全部丢失，虚函数表也被复制成了Base的vtable，多态完全失效。这就是切片。

切片在嵌入式里经常导致隐秘bug，尤其是把对象放进容器的时候。解决方式很直白：参数用Base的引用void show(Base& b)或者指针，不要在容器里存Base对象，存指针或智能指针。面试回答里能主动提到切片问题，是加分项。

3.3 纯虚函数与抽象类：设计接口的正确姿势

面试中很多时候会让候选人现场口述一个驱动框架设计，这时候纯虚函数就是核心工具。比如这样一个场景：设备上有多个温度传感器，来自不同厂商，接口不同，但业务代码希望统一的读取方式。

好的设计是定义一个抽象类：

class ITemperatureSensor { public: virtual float readCelsius() = 0; virtual int open() = 0; virtual void close() = 0; virtual ~ITemperatureSensor() = default; };

然后每个厂商芯片写一个派生类，实现自己的readCelsius。业务层只依赖ITemperatureSensor*接口，底层换了传感器芯片，编译时只需换一个工厂函数，业务代码一行不用改。这就是设计模式里的依赖倒置，嵌入式驱动分层时非常实用。

这里要提醒一个常见误解：“抽象类就是有纯虚函数的类，不能实例化”，这点没错，但更准确地说，只要类里存在一个纯虚函数，它就是抽象类，不能直接创建对象。另外纯虚函数也可以有函数体，不过很少用，知道有这回事就行。

3.4 常见面试变种：删除基类指针到底会发生什么

我面试时经常把前面的考点串起来，出一道类似这样的综合题：“基类指针指向new出来的派生类对象，delete掉它，请问哪些析构函数被执行？如果没有虚析构又会怎样？”

有虚析构时，delete执行表达式会根据动态类型调用Derived析构，Derived析构跑完后再自动调用Base析构，整体是派生到基类的顺序，所有资源都释放。没有虚析构时，行为是未定义。实际在非虚析构情况下，大多数编译器会静态绑定到Base的析构，于是Derived的成员根本没被清理。在资源受限的嵌入式环境里，这就等于驱动没停、中断没关、DMA还在跑，就算内存不崩溃，外设状态也乱套了。

这个问题考察的是堆上对象的管理意识。在嵌入式里malloc/new出来的对象，delete操作一定不能马虎，尤其涉及继承体系时，虚析构就是一道保险。

表中第二行尤其注意：只有通过基类接口删除时才需要虚析构，如果永远直接操作派生类对象，虚析构确实没有额外作用。问题是你写代码时无法保证所有调用方都只用派生类指针，所以还是那句：带虚函数的基类一律虚析构。

4. 拷贝构造：从深拷贝到“三次拷贝”血泪坑

4.1 拷贝构造函数的触发时机，面试高频之一

拷贝构造的考点非常多，面试最常问的第一个问题就是“什么时候会调用拷贝构造函数”。很多候选人会说“赋值的时候”，这是错的。赋值运算符和拷贝构造是两回事，区别非常明显：

class Widget { public: Widget() = default; Widget(const Widget& other) { printf("copy ctor of Widget\n"); } Widget& operator=(const Widget& other) { printf("copy assignment of Widget\n"); return *this; } }; Widget a; Widget b(a); // 拷贝构造 Widget c = a; // 拷贝构造（依然是初始化，不是赋值） Widget d; d = a; // 拷贝赋值

拷贝构造函数触发时机有四类。第一类是用已有对象初始化新对象（包括等号初始化语法）；第二类是函数参数按值传递；第三类是函数按值返回局部对象；第四类是标准容器里以值方式插入对象（vector的push_back、insert等）。C++17以后，按值返回时不可拷贝的类也可以直接返回（强制拷贝省略），这是新特性，但嵌入式编译器版本较老时不一定支持，最好主动问一句“你们的工具链支持C++17吗”。

面试时能补充一句“区分初始化和赋值的关键在于是否存在一个正在被创建的新对象”，就能让面试官知道你是真的理解这个语义，而不是背了四个时机。

4.2 浅拷贝的罪与罚

拷贝构造的重头戏是深拷贝。当你没有显式定义拷贝构造函数时，编译器会生成一个默认版本，它做的事就是对每个成员按字节拷贝。对内置类型没问题，对指针成员就是灾难。

看一个典型的Buffer类：

class Buffer { public: Buffer(size_t size) { m_size = size; m_data = new char[size]; } ~Buffer() { delete[] m_data; } private: char* m_data = nullptr; size_t m_size = 0; };

这个类没写拷贝构造，于是Buffer b2 = b1时，编译器只是把b1的m_data指针值复制给了b2。两个对象的m_data指向同一块内存，析构时第一遍delete成功，第二遍delete就是double free，轻则程序崩溃，重则堆内存管理结构被破坏导致系统随机故障。嵌入式系统里堆通常很小，这种问题更容易触发踩内存、死机、HardFault一类的问题。

面试中答到这个程度，已经能得大部分分了。如果你能继续补充：默认拷贝构造是逐位拷贝（bitwise copy），对含指针、文件句柄、设备描述符的类，必须手动实现深拷贝或者禁用拷贝，这就说明你真的有实战经验，而不是只会背概念。

4.3 深拷贝的正确打开方式与拷贝赋值运算符

深拷贝的写法不难，但要注意细节。要写成这样：

class Buffer { public: Buffer(size_t size) : m_size(size), m_data(new char[size]) {} Buffer(const Buffer& other) : m_size(other.m_size), m_data(new char[other.m_size]) { memcpy(m_data, other.m_data, m_size); } Buffer& operator=(const Buffer& other) { if (this != &other) { // 1. 先分配新内存，再释放旧内存，防止自赋值 char* newData = new char[other.m_size]; memcpy(newData, other.m_data, other.m_size); delete[] m_data; m_data = newData; m_size = other.m_size; } return *this; } ~Buffer() { delete[] m_data; } private: char* m_data = nullptr; size_t m_size = 0; };

注意拷贝赋值运算符里两个关键点。一是自赋值检查，b = b这种情况必须有，否则先delete再copy就出问题。二是顺序问题：先new新内存、拷贝数据，再释放旧内存，这样就保证了如果new抛异常（嵌入式虽然默认关了异常，但new可能返回nullptr），原始数据还没被释放，对象处于安全状态。这种代码风格叫“copy-and-swap”的简化版，够应付大多数面试场景。

这里强调一下，写深拷贝时一定要同时考虑拷贝构造、拷贝赋值、析构函数这三者，它们是一个整体。面试官非常喜欢问“你写了拷贝构造，为什么还要写拷贝赋值”，答案就是二者触发的时机不同、处理方式有区别，但资源管理意图一样。

4.4 嵌入式场景下的特殊注意点

嵌入式场景里拷贝构造有更多需要注意的地方，这也是面试官想听的差异化内容。

第一类是大型对象的拷贝成本。一个1MB的音频缓冲区，如果函数按值传入传出，每次都发生整块内存拷贝，对嵌入式CPU和RAM都是巨大的浪费。正确做法是传引用或者传指针，必要时用const T&。

第二类是外设资源类不允许拷贝。比如Mutex互斥锁、GPIO控制句柄、UART句柄，这些类代表了系统独占资源。一旦发生拷贝，两个对象共享同一个底层句柄，析构时产生了重复释放的竞争条件。正确做法是把拷贝构造和拷贝赋值删除掉：

class GpioPin { public: GpioPin() = default; GpioPin(const GpioPin&) = delete; GpioPin& operator=(const GpioPin&) = delete; };

第三类最容易被忽略，就是移动语义。C++11引入了移动构造，本质是“把资源所有权转移过去”，不用拷贝数据，只需要把临时对象的指针置空，就像你要搬家不会把旧房子的墙拆了搬走，而是拿着钥匙和行李直接入住新房。嵌入式里移动语义对高效处理大块数据尤其有优势。比如一个串口接收函数返回一个动态数组，有了移动构造，返回时就不用整块拷贝了。

面试回答时只要提到“对于资源管理型或大块内存型对象，优先考虑移动语义，避免不必要的深拷贝”，就说明你是跟得上现代C++思路的嵌入式工程师，不是停留在教科书C++98年代。

5. 三个考点的“串珠”式追问，死记硬背最容易翻车

5.1 面试连环问第1关：虚函数表能否被拷贝

面试官前面可能分别问完三个知识点，然后就进入压力面试环节，开始把知识点串起来问。比如：“一个带虚函数的类对象发生拷贝时，vptr会被拷贝吗？会的话有什么影响？”

答案是：vptr也会被浅拷贝。拷贝构造时，编译器会从源对象的虚表中取出vptr值，复制给目标对象。由于源对象和目标对象的实际类型相同，vptr正常情况下指向同一个vtable，所以拷贝后虚函数行为通常是一致的。这里不能说是浅拷贝，因为vptr本身是个指针，复制的是指针值，这正是浅拷贝。

但如果用基类去拷贝一个派生类对象（而且你把拷贝构造函数写成Base(const Base&)），情况就不同了。派生类对象在拷贝时，采用基类拷贝构造，只会把派生类对象中的Base部分拷贝过来，放入一个新Base对象。此时新对象的类型是Base，vptr指向Base的vtable，派生类虚函数行为全部丢失，确确实实发生了切片。所以拷不拷贝vptr不重要，重要的是拷贝后对象的动态类型是什么。

5.2 面试连环问第2关：vector里放对象怎么避开拷贝地狱

这道题特别能考察对容器与对象机制的组合理解。比如面试官问：“如果我定义一个std::vector<Base>，往里push一个Derived对象会怎样？”

答案是：vector存的是Base的实例，当Derived对象被拷贝到vector内部时，编译器调用Base的拷贝构造，发生切片，Derived的部分全部丢失。更麻烦的是，vector扩容时所有元素都要跟着移动或拷贝，如果Base是带vptr的多态类，元素拷来拷去，动态类型也早就被切得干干净净。

正确的做法有两种。一是存智能指针，std::vector<std::unique_ptr<Base>>，这样元素是堆对象，指针不存在切片，多态也保留。二是在资源受限场景不想引入堆分配，就用std::vector<std::reference_wrapper<Base>>来引用栈对象，但要注意对象生命周期不能短于容器生命周期。

而且vector扩容也是个考点：capacity不够时，vector会重新分配内存，把所有元素搬到新内存中。如果元素是可移动的，就走移动构造；如果没写移动构造但有拷贝构造，就退化为拷贝。如果你没有正确处理这些函数的资源语义，整个过程可能因为频繁深拷贝把MCU的RAM瞬时打爆，这也是嵌入式面试爱问vector的原因——它把你的C++基本功和工程敏感度一次都测了。

5.3 面试连环问第3关：多态对象传参的正确姿势

最后一个连环问通常是：“多态对象作为参数传入函数时，应该用什么方式传？为什么？”

最稳妥的回答是：以基类引用或指针传参，不要按值传参。按值传参就是切片；传引用或指针才能保证动态类型不丢，虚函数正常分发。如果只读使用，用const Base&；如果需要修改对象且需要保留多态行为，用Base&；如果允许空值、或者需要动态转移所有权，用指针或者智能指针。

值得注意的是引用和指针的区别：引用无法为空、无法改变所指目标，调用形式上更自然；指针允许为空，可指向不同对象，灵活性更高。嵌入式代码风格里两者都常见，但驱动框架、回调接口里用指针更多，因为要配合函数指针、上下文结构体这类C语言惯用法。

再多说一句，如果函数需要返回多态对象本身，永远不要返回基类类型的局部对象副本，应该返回std::unique_ptr<Base>或直接返回派生类对象并依赖移动语义，这一点对嵌入式场景效率影响很大。

5.4 面试连环问第4关：什么时候用多态，什么时候别用

讲完上面三道连环问，面试官基本会出最后一关：“你觉得在嵌入式里，什么时候该用虚函数和多态？什么时候不该用？”

这个问题回答得好，基本就拿到了offer。说几个我认可的回答方向。

该用的情况：模块与模块之间通过接口解耦、驱动需要抽象多个具体型号、业务层需要依赖稳定的接口而不是具体实现、代码运行期需要切换算法或协议栈。典型例子是协议栈抽象、显示驱动抽象、传感器驱动框架。

不该用的情况：每个对象都必须多占一个vptr内存且对象数量巨大的内存池；高频调用的小函数，虚函数导致内联失效和间接跳转；中断上下文或硬实时任务中，虚调用的执行时间不确定；需要严格C ABI兼容的边界（比如给纯C模块提供的回调函数，就不适合用虚函数）。

能给出这种“分场景、有取舍”的回答，说明你是真正的嵌入式从业者，而不是只会背面的学生。我对这类候选人印象分整体很高。

6. 像面试官一样给自己做一次“压力测试”

6.1 一张自测清单，你漏了哪些点

如果你看完前面内容，感觉似乎都懂，建议拿这张清单快测一下。每一条都要能做到“不看任何资料，直接口头讲明白”的程度，才算过关。

如果某一条回答得含糊，建议回去翻翻上面对应小节，重新组织一下语言。面试就是限时表达，你能不能在20秒内把重点讲清楚，比你会多少细节更重要。

6.2 现场答题示范：结构化表达的三段式

面试回答技术问题时，推荐大家用“结论—机制—工程取舍”三段式结构，这是我自己面试时比较认可的答题方式。

比如面试官问“为什么析构函数通常要设为虚函数”，不要上来就背“因为派生类析构就不会被调用”，这样太单薄。比较完整的回答是：

“结论上，通过基类指针删除派生类对象时，析构函数必须是虚函数，否则派生类析构不会执行。”（先给结论）

“机制上，delete一个基类指针时，编译器会根据指针的静态类型去调用析构函数。如果析构函数是虚的，就会像普通虚函数一样通过vptr查找实际类型的析构函数；如果不虚，就只调用基类析构，派生类资源和管理代码丢失。”（讲底层）

“工程取舍上，凡是带虚函数的类，我一律把析构函数写成虚的。虽然这会多占一个函数指针空间，但换来的是安全性和一致性。对嵌入式来说，代价可接受，收益却很大。”（说取舍）

这样三段下来，面试官能清晰听到你的想法，甚至不用再追问就给你过了。平时自己练题时也建议用这个结构口述几遍，熟能生巧。

6.3 我的体会：把面试题当工程题去做

最后说说我自己这些年面试别人和被面试时的体会，这可能是比任何答案模板都重要的东西。

面试题表面上考的是语法知识，但面试官真正想看到的，是你在真实工程里有没有踩过那些坑。虚函数考的是你有没有做过设备驱动抽象，多态考的是你有没有搭过可扩展的框架，拷贝构造考的是你有没有被double free和内存泄漏折磨过。所以准备面试时，不要死背定义，而是翻翻你自己写过的项目代码，想清楚哪些地方用了多态、哪些地方因为浅拷贝出了bug、哪些类应该有虚析构却漏了。把面试题和你真实的工程经验连接到一起，你讲出来的东西才有说服力。

另外一个小建议：有条件的话，找同学或者同事模拟一下面试，把这三个考点轮番问你一遍。你会发现，第一次回答和第二次回答的语感完全不一样。面试要的不是“知道”，而是“能在压力下讲清楚”。提前练过，现场就不慌。

这次分享就到这里。上面讲的东西，很多是我在实际面试中看到候选人反复踩的坑，也是自己做驱动开发时真正遇到过的问题。希望你能把这些内容消化成自己的语言逻辑，而不是复制粘贴背下来。毕竟面试官每年见过几百个背答案的人，真正让他眼前一亮的，永远是那个“做题时带脑子、答宽容时带取舍”的候选人。