罗罗编程学习记录 全栈面试题库
本页导航 展开查看

14.2 阶段 1 语言基础与现代特性

所属:全栈开发面试题库 / 学习路径 / 14 C++ 与系统开发

本页目录

一、阶段定位

本阶段解决"用什么语法写现代 C++"。不是从零讲变量和循环——有其他语言基础的人这些都懂——而是讲清楚 C++ 区别于 C/Java/Python 的部分:值类别、引用、auto、lambda、模板基础、RAII 思想、C++20 新特性。这些东西是后面阶段 2 内存管理、阶段 3 STL、阶段 4 并发的语法地基。

不掌握本阶段会在后面具体卡在哪:

  • 分不清左值、右值、将亡值,到阶段 2 学移动语义时完全看不懂 T&& 到底是什么。
  • 写函数参数习惯用 const string s 而不是 const string& s,每次调用都拷一次字符串,到阶段 6 做性能剖析时才发现热点全在拷贝构造。
  • 看不懂模板报错,一堆 error: no matching function for call to ... 里嵌套十几层 note,直接放弃读报错。
  • 不知道 RAII 是什么,到阶段 2 学智能指针时把 unique_ptr 当成"会自动 delete 的裸指针",写出 unique_ptr<T>(new T) 到处拷贝的代码。

判断自己卡住的标志:(1) 让你说出 int&、const int&、int&& 的区别,你只能说"都是引用";(2) 给你一段带 auto、lambda、范围 for 的代码,你看不懂类型推导过程;(3) 编译器报模板错,你不知道从哪一行开始读 note。出现任一现象,先把本阶段六个模块过一遍再进 阶段 2 内存管理与对象生命周期。

二、阶段目标与投入

能力目标(可验证的行为) 验证方式
能区分左值、右值、将亡值,写出 T&、const T&、T&& 参数函数 给一段代码,标注每个表达式的值类别
能熟练使用 auto、范围 for、constexpr、nullptr 重写一段 C 风格代码为现代 C++ 风格
能写 lambda 并捕获变量,理解按值捕获与按引用捕获的区别 用 lambda 作为标准库算法参数
能读懂简单模板定义,写出一个函数模板 写一个 template<typename T> T maxof(T a, T b)
能说明 RAII 思想,用栈对象管理资源 写一个用 std::lock_guard 保护临界区的示例
能列出 C++20 主要特性并说出用途 口述 concepts、ranges、coroutines、modules 等特性名与用途

建议学时:

  • 全职(每天 4–6 小时):3–4 周,约 60–80 小时。其中值类别与引用 12 小时、现代语法(auto/lambda/constexpr)12 小时、模板基础 16 小时、RAII 与智能指针入门 12 小时、C++20 特性 12 小时、动手练习 16 小时。
  • 在职(每天 2 小时、周末补 4 小时):6–8 周,约 70 小时。写过 C 的人可压缩现代语法部分,但值类别与模板必须重学。

学时分配:值类别与引用 20%、现代语法 15%、模板基础 25%、RAII 入门 15%、C++20 特性 15%、动手练习 10%。

三、先修自检

先修项 合格标准 不合格时怎么办
至少一门其他语言 能写循环、函数、条件分支,理解变量与作用域 先补一门语言基础,再开始 C++
命令行编译 能用 g++ 编译运行一个 cpp 回到 阶段 0
指针概念 理解指针存地址、解引用、nullptr 用两天写几个 C 风格小程序练手
英文报错阅读 能看懂 error: expected ';' 这类基础报错 遇到报错先抄原文再查

四、知识地图

模块 知识点 掌握程度 对应题库章节
类型系统 基本类型、auto、decltype、constexpr、nullptr 会用 04.9.1 指针内存布局与 RAII
值类别 左值、右值、将亡值、T&、const T&、T&& 能讲清原理 04.9.1 指针内存布局与 RAII
函数 参数传递方式(值/左值引用/右值引用/指针)、返回值、重载、默认参数 会用 04.9.1 指针内存布局与 RAII
lambda 捕获列表、捕获方式、泛型 lambda、std::function 会用 04.9.2 STL 容器与迭代器失效
模板 函数模板、类模板、模板参数推导、特化基础 会用 04.9.2 STL 容器与迭代器失效
RAII 构造获取资源、析构释放资源、栈对象生命周期 能讲清原理 04.9.1 指针内存布局与 RAII
C++20 concepts、ranges、coroutines、modules、std::format、std::span 了解 04.9.1 指针内存布局与 RAII

五、分模块精讲

5.1 值类别与引用

为什么需要它:C++ 的函数参数选择(值传、引用传、指针传)直接决定拷贝次数与所有权。选错了,性能差、语义错。

核心机制:

  • 左值(lvalue):有名字、可取地址的表达式,如变量 x、函数返回左值引用。
  • 右值(rvalue):临时对象、不可取地址的表达式,如 42、std::string("hello")、函数返回非引用。
  • 将亡值(xvalue):即将被销毁的右值,如 std::move(x) 的结果。
  • T&:绑定到左值;const T&:绑定到左值或右值(可延长临时对象生命周期);T&&:绑定到右值(将亡值),用于移动语义。
  • 参数选择经验:输入只读用 const T&;需要修改输入用 T&;需要转移所有权用 T&& 或传 unique_ptr;小对象(int、double)直接值传。

最小可运行示例:

#include <iostream>
#include <string>

void taking_by_value(std::string s) { std::cout << "value: " << s << "\n"; }
void taking_by_ref(const std::string& s) { std::cout << "cref: " << s << "\n"; }
void taking_by_rref(std::string&& s) { std::cout << "rref: " << s << "\n"; }

int main() {
    std::string name = "ann";        // name 是左值
    taking_by_value(name);           // 拷贝一次
    taking_by_ref(name);             // 不拷贝
    taking_by_ref(std::string("tmp")); // const 引用延长临时对象寿命
    taking_by_rref(std::move(name));  // 转移所有权,name 此后为空
    return 0;
}

常见坑:

现象 原因 修法
cannot bind rvalue to lvalue reference 把临时对象传给 T& 改 const T& 或 T&&
大对象拷贝导致性能差 函数参数用了 T 而不是 const T& 改引用传参
std::move 后变量还在用 移动后对象处于"有效但未指定"状态 移动后不要再读原变量

5.2 auto、lambda 与现代语法

为什么需要它:C++11 以后语法密度大幅提高,不会 auto、lambda、范围 for,代码会写得又长又丑。

核心机制:

  • auto:让编译器推导类型,但 auto 会丢弃引用与 const(auto x = ... 得到值);要保留引用写 auto&,保留 const 写 const auto&。
  • 范围 for:for (const auto& item : container) 遍历容器,避免索引越界。
  • lambda:[捕获](参数) -> 返回类型 { 体 };捕获 [=] 按值、[&] 按引用、[x] 只捕 x;泛型 lambda 用 [](auto a, auto b){...}。
  • constexpr:编译期可求值的函数或变量,用于常量表达式与模板参数。
  • nullptr:替代 C 的 NULL,类型安全。

最小可运行示例:

#include <algorithm>
#include <iostream>
#include <vector>

int main() {
    std::vector<int> nums = {5, 2, 8, 1, 9};
    auto threshold = 3;                      // auto 推导为 int
    std::sort(nums.begin(), nums.end(), [](int a, int b) {
        return a > b;                        // 降序
    });
    for (const auto& n : nums) {             // 范围 for,引用避免拷贝
        std::cout << n << " ";
    }
    std::cout << "\n";
    auto count = std::count_if(nums.begin(), nums.end(),
        [&threshold](int n) { return n > threshold; });
    std::cout << "greater than " << threshold << ": " << count << "\n";
    return 0;
}

常见坑:

现象 原因 修法
lambda 里改了外部变量不生效 用了 [=] 按值捕获 改 [&] 或显式按引用捕
auto 推导出意外类型 函数返回 T& 但 auto 丢弃了引用 写 auto& 或 const auto&
范围 for 里修改容器元素 用了 const auto& 改 auto&

5.3 模板基础

为什么需要它:STL 全是模板,不会读模板定义就无法理解 std::vector<T>、std::sort 的签名,写泛型代码更无从下手。

核心机制:

  • 函数模板:template<typename T> T maxof(T a, T b) { return a > b ? a : b; },编译器在调用时根据实参推导 T 并实例化。
  • 类模板:template<typename T> class Stack { ... };,使用时必须显式指定 Stack<int>。
  • 模板在头文件里实现(因为编译期实例化需要看到完整定义),这是 C++ 与 Java 的重大区别。
  • 模板报错:报错信息很长,从最后一行往上读,找到 note: candidate template ignored: ... 看为什么不匹配。

最小可运行示例:

#include <iostream>
#include <string>

template<typename T>
T maxof(T a, T b) {
    return a > b ? a : b;
}

template<typename T>
class Box {
    T value_;
public:
    explicit Box(T v) : value_(v) {}
    const T& get() const { return value_; }
};

int main() {
    std::cout << maxof(3, 7) << "\n";                  // 推导 T=int
    std::cout << maxof(std::string("abc"),
                       std::string("abd")) << "\n";    // 推导 T=string
    Box<int> int_box(42);
    std::cout << int_box.get() << "\n";
    return 0;
}

常见坑:

现象 原因 修法
链接报 undefined reference to maxof<int>(int, int) 模板实现写在了 .cpp 里 把模板实现移到头文件
模板报错看不懂 报错嵌套十几层 note 从最后一行往上读,找 candidate template ignored
maxof(3, 4.5) 编译失败 T 推导为 int 还是 double 冲突 显式 maxof<double>(3, 4.5)

5.4 RAII 思想

为什么需要它:C++ 没有 Java 的 GC,也没有 Go 的 defer。资源(内存、文件、锁、socket)靠"栈对象析构"自动释放,这就是 RAII。不会 RAII,到处 new/delete、fopen/fclose,迟早泄漏。

核心机制:

  • RAII(Resource Acquisition Is Initialization):在构造函数里获取资源,在析构函数里释放资源。栈对象离开作用域时析构函数自动调用,即使抛异常也会执行。
  • 典型应用:std::lock_guard<mutex>(构造加锁、析构解锁)、std::fstream(构造打开、析构关闭)、std::unique_ptr(构造持有、析构 delete)。
  • 与 Java try-with-resources、Go defer 思路类似,但 C++ 是"对象生命周期即资源生命周期",不需要显式声明。

最小可运行示例:

#include <fstream>
#include <iostream>
#include <mutex>

std::mutex g_mutex;

void write_to_file(const std::string& path, const std::string& content) {
    std::lock_guard<std::mutex> lock(g_mutex);   // 构造即加锁
    std::ofstream out(path);                       // 构造即打开
    out << content;
    // 离开作用域:out 析构关闭文件,lock 析构解锁
    // 即使抛异常也会正确释放
}

int main() {
    write_to_file("demo.txt", "hello raii\n");
    return 0;
}

常见坑:

现象 原因 修法
函数中途 return,资源没释放 用了裸 new/delete 或 fopen/fclose 改用 RAII 对象(unique_ptr、fstream)
异常导致锁没释放 手动 lock() 后异常路径没 unlock() 用 std::lock_guard

5.5 C++20 主要特性

为什么需要它:现代 C++ 招聘要求 C++20 起步。不了解 concepts、ranges、coroutines,看 Muduo、Folly、abseil 源码时会卡住。

核心机制:

  • concepts:给模板参数加约束,替代 std::enable_if,报错更友好。如 template<typename T> requires std::integral<T> T add(T a, T b) {...}。
  • ranges:管道式算法,vec | std::views::filter(...) | std::views::transform(...),延迟求值,不产生中间容器。
  • coroutines(协程):co_await、co_return、co_yield,用于异步 IO 与生成器,阶段 7 深入。
  • modules:替代 #include,编译更快;import std;(C++23,待确认)。
  • std::format:Python 风格格式化,替代 sprintf 与 std::cout 拼接,类型安全。
  • std::span:表示连续内存的视图,参数传 span<T> 替代裸指针 + 长度。

最小可运行示例:

#include <format>
#include <iostream>
#include <ranges>
#include <vector>

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    auto even_squares = nums
        | std::views::filter([](int n) { return n % 2 == 0; })
        | std::views::transform([](int n) { return n * n; });
    for (int v : even_squares) {
        std::cout << std::format("{} ", v);    // 4 16 36 64 100
    }
    std::cout << "\n";
    return 0;
}

常见坑:

现象 原因 修法
std::format 编译失败 编译器版本太老 GCC 13+ / Clang 17+ / MSVC 19.3x 才完整支持
ranges 管道报错看不懂 视图类型嵌套深 用 auto 接收,不要手写类型
modules 链接失败 模块编译单元配置不对 阶段 6 CMake 配 CMAKE_CXX_SCAN_FOR_MODULES

5.6 头文件与源文件分离

为什么需要它:C++ 项目组织方式与其他语言不同——头文件放声明,源文件放定义,模板是例外。不会组织头文件,编译会爆重定义或慢得无法忍受。

核心机制:

  • 头文件(.h):放函数声明、类定义、模板实现;用 #pragma once 或 include guard 防止重复包含。
  • 源文件(.cpp):放非模板函数的实现;#include 对应头文件。
  • 模板实现必须在头文件(编译期实例化需要看到完整定义)。
  • 不要在头文件里写 using namespace std;,会污染所有包含它的源文件。

最小可运行示例:

// math_utils.h
#pragma once
int add(int a, int b);

template<typename T>
T maxof(T a, T b) { return a > b ? a : b; }
// math_utils.cpp
#include "math_utils.h"
int add(int a, int b) { return a + b; }

常见坑:

现象 原因 修法
multiple definition of add 函数实现写在头文件且被多个 cpp 包含 实现移到 .cpp,或加 inline
头文件循环依赖 A.h 包含 B.h,B.h 又包含 A.h 用前置声明 class B; 替代包含

六、分层练习

6.1 复现型

练习 要求 验收标准 预计耗时
值类别标注 给一段代码,标注每个表达式是左值/右值/将亡值 10 个表达式全部标对 2 小时
lambda 排序 用 lambda 对 vector<pair<string,int>> 按第二字段降序 排序结果正确 1 小时
函数模板 写一个 maxof 模板,支持 int、string、double 三种类型都能编译运行 1 小时
RAII 锁 用 lock_guard 保护一个共享变量的写操作 故意抛异常,锁仍正确释放 1 小时
ranges 管道 用 ranges 过滤偶数并平方 输出 4 16 36 64 100 1 小时

6.2 改造型

练习 要求 验收标准 预计耗时
C 风格改现代 C++ 给一段用 char*、malloc、printf 的代码,改成 string、unique_ptr、std::format 编译 0 警告,行为一致 3 小时
参数传递优化 给一个用 const string 传参的函数,改成 const string&,用 perf 或计时器对比 拷贝次数减少 2 小时
模板报错修复 故意触发一个模板不匹配报错,读 note 找到原因 能说清为什么编译器推导失败 2 小时
头文件重组 给一个把所有代码堆在 main.cpp 的工程,拆成头文件 + 源文件 CMake 构建 0 警告 0 错误 2 小时

6.3 设计型

练习 要求 验收标准 预计耗时
设计一个泛型容器 写一个 template<typename T> class Stack,支持 push/pop/size 编译通过,测试 int 与 string 4 小时
整理值类别笔记 用表格列出左值/右值/xvalue 的典型表达式与可绑定引用 20 个以上例子 2 小时
选型对比 为"字符串拼接"场景比较 const string&、string_view、string&& 三种参数 能说清各自适用场景 2 小时

七、排障表

现象 可能原因 排查步骤 解决办法
cannot bind rvalue to lvalue reference 临时对象传给 T& 看函数签名 改 const T& 或 T&&
no matching function for call to 'xxx' 模板实参推导失败或重载不匹配 从最后一行往上读 note 显式指定模板参数,或检查类型
undefined reference to template xxx 模板实现写在 .cpp 看报错符号 把模板实现移到头文件
multiple definition of xxx 非 inline 函数在头文件定义 看哪个头文件被多个 cpp 包含 实现移到 .cpp 或加 inline
lambda 捕获变量改了不生效 按值捕获 [=] 看捕获列表 改 [&] 或显式按引用
std::format 链接失败 编译器版本不支持 看版本号 GCC 13+ / Clang 17+
头文件改了但没重新编译 CMake 依赖关系 删 build 目录 重新配置构建

八、出口条件

全部勾选后进入 阶段 2 内存管理与对象生命周期。

  • [ ] 能区分左值、右值、将亡值,写出 T&、const T&、T&& 适用场景
  • [ ] 能熟练用 auto、范围 for、lambda、constexpr、nullptr
  • [ ] 能写函数模板与类模板,并把模板实现放在头文件
  • [ ] 能说明 RAII 思想,用 lock_guard、fstream、unique_ptr 自动管理资源
  • [ ] 能列出 C++20 concepts、ranges、coroutines、modules、std::format、std::span 的用途
  • [ ] 能区分头文件与源文件职责,避免重定义与循环依赖
  • [ ] 能读懂模板报错的 note 链,定位推导失败原因

自测题:

  1. 左值、右值、将亡值的区别?T&、const T&、T&& 分别绑定什么?
    • 要点:左值有名字可取地址;右值是临时对象;xvalue 是 std::move 结果。T& 绑左值;const T& 绑左值或右值;T&& 绑右值。
  2. RAII 是什么?为什么异常安全代码离不开它?
    • 要点:构造获取资源、析构释放资源;栈对象离开作用域自动析构,即使异常也会执行。
  3. 模板实现为什么要放在头文件?
    • 要点:编译期实例化需要看到完整定义;放 .cpp 会导致链接时找不到实例化符号。
  4. auto 与 auto& 的区别?什么时候用 const auto&?
    • 要点:auto 丢弃引用与 const;auto& 保留引用;遍历大容器只读时用 const auto& 避免拷贝。
  5. C++20 ranges 相比传统 STL 算法的优势?
    • 要点:管道式组合、延迟求值、不产生中间容器,代码更可读。
  6. 头文件里为什么禁止 using namespace std;?
    • 要点:头文件会被多个源文件包含,展开后污染全局命名空间,可能导致名字冲突。