C++ 基础概念与面试高频点整理

派生类重写基类虚函数后，虚表里对应的函数地址会被替换成派生类版本，所以同一个基类接口，最终可以落到不同实现上。

虚析构函数

如果一个类打算作为基类使用，析构函数通常应该声明为虚函数。否则，通过基类指针删除派生类对象时，可能只调用基类析构，派生类自己的资源就清不干净。

构造函数为什么不能是虚函数

构造阶段对象还没完全成型，虚函数机制依赖的虚表指针也还没稳定建立起来。构造函数本身就是'把对象造出来'的过程，它不能再依赖已经完成对象之后才能工作的机制，所以构造函数不能是虚函数。

重载、重写、隐藏

• 重载：同一作用域内，函数名相同，参数列表不同。
• 重写：派生类重新实现基类的虚函数，函数名和参数列表都保持一致。
• 隐藏：派生类定义了一个同名函数，把基类中同名函数遮住了，常见于参数列表不同，或者基类函数不是虚函数的情况。

这几个概念很容易混。实战里最常出问题的不是'有没有写对'，而是'调用时编译器到底看到了谁'。

引用

引用可以看作变量的别名。创建时必须初始化，之后就一直绑定到那个对象，不能再改绑到别的对象。

引用常见的好处有几个：

• 传参时避免拷贝大对象，性能更好。
• 语法比指针直接，少了不少解引用和空指针的麻烦。
• 函数返回引用时，可以把结果当左值继续使用。

引用不能初始化为空，因为它一出生就必须对应一个有效对象。它不是'稍后再决定指向谁'的东西，这点和指针不一样。

引用和指针的区别

• 指针保存的是地址，可以改变指向；引用是别名，绑定后不能改。
• 访问对象时，指针要解引用，引用可以直接用。
• 指针可以有多级，引用没有多级引用这个概念。
• 指针可以为空，引用不行。
• 引用自增是对目标值自增，指针自增是地址偏移。

还有一个常见坑：函数返回局部变量的引用或者指针都不安全。局部对象出作用域就销毁了，返回出去的东西很容易变成悬空引用或野指针。

内存分区

堆和栈

堆内存通常由程序员手动申请和释放，常见接口是 new / delete、malloc / free。栈内存则由编译器自动管理，函数结束后自动回收。

堆更灵活，但也更容易出错；栈省心，但空间和生命周期都比较受限。

const 指针

这里面最容易绕的就是 const 的位置。

1. 指向常量的指针：const 修饰的是指向的内容，指针可以改地址，但不能通过它改值。
2. 常量指针：const 修饰的是指针本身，地址不能改，但内容能不能改要看对象本身是不是常量。
3. 指向常量的常量指针：地址和内容都不能通过这个指针改。

NULL 和 nullptr

在 C 语言里，NULL 传统上常被定义成 (void*)0；而在 C++ 中，NULL 更常被定义成 0。这背后其实是类型系统差异：C++ 对类型转换检查更严格，不希望把空指针和整数混在一起。

C++11 之后更推荐直接用 nullptr。它有自己的类型 std::nullptr_t，不会被误当成整数，也更清楚地表达'这里就是空指针'。这比 0 或 NULL 都稳妥。

构造函数和析构函数

构造函数

构造函数名和类名相同，没有返回值，也不写 void。对象创建时自动调用它。

如果没有自己写构造函数，编译器通常会生成默认的无参构造函数。

构造函数的核心作用是初始化对象状态。严格说，真正做初始化的是初始化列表，不是构造函数体里的赋值。这个区别在成员为 const、引用或自定义类型时尤其明显。

拷贝构造

拷贝构造常见触发场景有两个：

• 用一个已有对象初始化新对象。
• 对象按值传参、按值返回。

拷贝构造参数一般要写成引用，通常还会加 const。如果参数不是引用，传参时又会触发一次拷贝，容易无限递归。

浅拷贝和深拷贝

• 浅拷贝：直接复制成员值，指针成员只复制地址。
• 深拷贝：重新分配资源，把内容真正拷贝一份。

如果类里管理堆内存，浅拷贝通常不够用，甚至会引发重复释放。这个问题面试里很爱问，原因也简单：它考的是你有没有真正理解'对象拥有资源'这件事。

析构函数

析构函数名和类名相同，前面加 ~，没有参数，也没有返回值。对象销毁时自动调用。

它的主要工作是释放对象持有的资源，尤其是成员变量指向的堆区内存。

new、delete、malloc、free

new 和 delete 是 C++ 的运算符，malloc 和 free 是 C 的库函数。它们都能做动态内存管理，但行为差别很大。

new 和 malloc

• new 会自动计算需要分配的类型大小，malloc 需要手动传字节数。
• new 返回正确类型的指针，malloc 返回 void*。
• new 可以重载，malloc 不能重载。
• new 失败通常会抛异常，malloc 失败一般返回空指针。
• new 会调用构造函数，malloc 不会。

delete 和 free

• delete 会先调用析构函数，再释放内存。
• free 只负责释放内存，不会调用析构函数。
• delete[] 适合释放数组对象，会逐个调用数组元素的析构函数。

这里最该记住的其实就一句：C++ 里对象的生命周期，不只是'拿到一块内存'，还包括构造和析构这两步。

C++11 的 lambda 表达式

Lambda 表达式是匿名函数，适合临时回调、局部逻辑处理、算法接口里塞一小段自定义规则。

它的优点很直接：不用额外写一个名字很长的函数，代码离使用点更近，读起来也更顺。

它也不是万能的。逻辑一复杂，lambda 就会变得难读，捕获列表和返回类型一多，维护成本会上来。所以我一般把它看作'局部小工具'，不是拿来替代所有函数的。

内联函数

内联函数的意思不是'更快的函数'，而是建议编译器把函数体展开到调用点，减少一次普通函数调用的开销。

它适合函数体很小、调用很频繁的场景。比如一些简单的 getter、setter，或者非常短的计算函数。

但内联也有代价：代码会变大。函数一旦被很多地方调用，展开后的代码重复度会很高。复杂函数、递归函数通常也不适合强行内联，编译器多半会直接忽略这个建议。

内联函数可以是虚函数吗

技术上可以写，但意义不大。虚函数靠运行时动态绑定，内联靠编译时展开，这两个机制天然就不太合拍。通过基类指针调用虚函数时，通常也很难真的内联起来。

智能指针

C++ 没有 Java 那种统一的垃圾回收机制，动态内存管理还是要自己负责。智能指针就是为了解决这个问题。

它的思路不复杂：对象销毁时自动释放资源，避免忘记 delete 带来的内存泄漏。使用前要包含 <memory>。

常见的智能指针有三种：unique_ptr、shared_ptr、weak_ptr。

unique_ptr

unique_ptr 强调独占所有权。同一时刻只有一个智能指针能持有资源，不能拷贝，只能移动。

如果要把资源交给另一个 unique_ptr，通常用 std::move 转移所有权。这个模型很干净，适合明确的单一所有者场景。

shared_ptr

shared_ptr 用引用计数实现共享所有权。多个 shared_ptr 可以共同管理同一块内存，最后一个持有者销毁时，资源才释放。

它适合多个模块共同使用同一对象的场景，但也别滥用。引用计数本身有开销，而且初始化方式如果不对，很容易出问题。不要用同一个原始指针反复去构造多个 shared_ptr，那样会导致重复释放。

正确做法是让一个 shared_ptr 接管对象，然后通过拷贝构造或移动构造把所有权继续传下去。

weak_ptr

如果两个 shared_ptr 互相持有对方，引用计数就永远降不到 0，资源也就不会释放。这就是循环引用。

weak_ptr 不增加引用计数，能观察对象是否还活着，但不拥有对象。打破循环引用时，把其中一端改成 weak_ptr，问题通常就解决了。

函数模板

函数模板让我们可以写一份通用代码，给不同类型复用。比如比较大小、交换值这类逻辑，用模板比为 int、float、double 各写一遍更省事。

关键字是 template。

模板也支持特化，也就是针对某些特殊类型写单独实现，不影响其他类型的通用版本。

模板的代价主要在编译期：不同类型会生成不同代码，容易让编译时间和代码体积变大。错误信息也常常比较长，第一次碰到模板报错的人都会被它折腾一下。

即便如此，模板依然是 C++ 里最重要的抽象工具之一。STL 的容器和算法基本都建立在模板之上，这也是它在工程里真正有用的地方。