网易C++校招笔试复盘：语法细节与高频算法全解析

网易2023校招笔试-C++开发工程师（正式第二批）这份卷子，我当时是卡着时间做完的，出来之后跟几个一起考的同学对了一圈答案，发现不少题大家错得都挺一致。现在复盘下来，这批题整体不算偏难怪，但很吃基本功，尤其是C++语法细节、STL的熟练度、以及对算法复杂度的敏感度。如果你正在准备C++开发岗位的校招笔试，这份复盘应该能帮你少走不少弯路。

1. 笔试整体复盘：题型分布与考察逻辑

1.1 试卷结构：三小时里到底考了什么

网易2023校招C++开发工程师的正式第二批笔试，时间给得挺充裕，我记得是三个小时。整套卷子大概是三块：选择题、编程题、还有一部分类似简答或者代码填空的内容。

选择题部分基本是C++语法为主，夹杂着数据结构、操作系统、网络的基础题。语法考察得非常细，比如const的修饰规则、static在不同场景下的含义、虚函数表的内存布局这类，没有扎实的底子很容易在一两个选项上犹豫半天。还考了一些C++11/14/17的新特性，类似auto推导的边界情况、右值引用和移动语义的辨析，这部分我在考场上有两道题是蒙的，复盘的时候才查清楚。

编程题一共四道，难度梯度还是比较明显的。第一题是签到题，基本是vector的简单操作加一点字符串处理；第二题开始上强度，考了一个字符串相关的模拟题；第三题是经典的数据结构应用题，我当时是用单调栈解的；第四题压轴，考的是图论和动态规划的结合，时间不够的话基本只能拿部分分。

比较有意思的是，这套卷子里还出现了一些工程向的考察点。比如有一道代码填空题，给了一段多线程代码，让你补全锁的用法；还有一道关于内存泄漏的简答题，问怎么定位和修复。这说明网易在筛人的时候，不只看你会不会写算法，更在意你有没有工程意识。

1.2 时间分配策略：先拿稳分再啃硬骨头

三个小时看着久，但如果你在选择题上卡太久，后面编程题的时间就会很紧张。我的建议是：选择题控制在40分钟以内，遇到拿不准的题先标记，不要恋战。我身边有同学就是选择题纠结太久，最后压轴题连题目都没看完，很可惜。

编程题建议从第一题开始往后做，先把该拿的分拿满。第四题如果五分钟之内没有清晰的思路，果断先写一个暴力解，拿部分分，等前面的题都提交了再回来优化。这批次笔试的编程题是ACM模式，要自己处理输入输出，不像LeetCode那样帮你封装好了，这个区别特别重要，后面我专门讲。

1.3 网易这批笔试的命题风格：偏工程落地，不偏难怪

把整套卷子刷下来，我的整体感受是：网易的题不跟你玩偏的怪的花活，但特别看重你把基础知识“用到实处”的能力。同样是考排序，它不问你快排的时间复杂度推导，而是给你一段几乎排好序的数据，问你在这种情况下哪种排序性能最好——这就是在考察你是否理解排序算法的适用场景，而不是背结论。

所以准备网易C++笔试，重心应放在：C++核心语法细节、STL容器与算法的熟练运用、经典数据结构的灵活变形、以及多线程和内存管理这些工程向主题上。它的每一道题背后都对应一个真实开发场景的抽象，这一点如果你之前写过多线程程序或者处理过线上内存问题，做题的时候会明显感觉更得心应手。

2. C++基础考点精讲：最容易丢分的语法细节

2.1 字符串初始化：一题暴露你的C++功底

这次笔试的选择题里有一道关于字符串初始化的题，看着很简单，但正确率据我后来跟同学对答案，其实不高。题目大概是让你判断下面几种初始化方式的区别：

std::string s1 = "hello"; // 拷贝初始化 std::string s2("hello"); // 直接初始化 std::string s3{"hello"}; // 列表初始化 std::string s4 = s1; // 拷贝构造 std::string s5 = std::move(s1); // 移动构造

这题表面考初始化语法，实际上考的是C++11之后的初始化列表优先级、拷贝与移动的触发时机、以及explicit构造函数对初始化方式的影响。

这里有个特别注意的点：如果用std::vector<int> v{5, 1}，这是列表初始化，结果是两个元素5和1；但如果写成std::vector<int> v(5, 1)，结果是5个1。笔试里就喜欢考这种括号和花括号的差异，我见过不止一次。刷题的时候如果你在VS Code里配置过C++环境，可以顺手把这类小例子跑一遍，加深印象，光看理论记不住。

2.2 constexpr的版本演进：从C++11到C++20

热词里有一条“constexpr哪个c++版本引入的”，这个知识点今年特别容易被考到，因为C++新标准迭代太快，很多人分不清。constexpr是C++11引入的关键字，用来声明“可以在编译期求值”的表达式或函数。

但要注意，C++11的constexpr函数限制非常严格，函数体内基本只能有一条return语句，不能有循环和局部变量。到了C++14放宽了这个限制，允许在constexpr函数中使用局部变量、循环、分支。C++17和C++20又进一步扩展了constexpr的适用范围，比如C++17里constexpr可以做lambda表达式，C++20开始支持在constexpr上下文中使用一些标准库容器。

网易这批笔试题里考了一道代码阅读题，给了个constexpr函数，问它是否符合C++11标准。我看到那道题的时候第一反应是“这函数能跑啊”，但仔细一看函数体里有for循环，在C++11标准下这就是非法的。这种题就是专门坑那些只熟悉最新标准、不了解历史演进的人。

2.3 读入整行：cin.getline的坑与正确写法

笔试编程题第一题就涉及字符串处理，很多人在读入包含空格的字符串时踩坑。直接用cin >> s遇到空格就停了，但题目要读的是“I love C++”这样的整行。

正确的做法是：

#include <iostream> #include <string> int main() { std::string line; std::getline(std::cin, line); // 读入一整行 return 0; }

但如果前面用了cin >> n，后面再跟getline，就会遇到一个经典问题：cin >> n读完数字后，缓冲区里还留了一个换行符，getline会把它当空行读走。解决办法是在两者之间加一句getline把残留的换行符吃掉，或者用cin.ignore()。

int n; std::cin >> n; std::cin.ignore(); // 吃掉换行符 std::string line; std::getline(std::cin, line);

在ACM模式的笔试里，输入输出处理如果出问题，代码逻辑再对也拿不到分，这个细节一定要专门练。我自己吃过一次亏之后，现在每次笔试前都会先写一遍这几种输入模式的模板，确保肌肉记忆。

2.4 结构体链表：基本语法不能含糊

链表相关的题在笔试中出现的频率很高，而它最基础的就是结构体的定义和节点的创建。网易这次在选择题里也考了一个结构体链表的语法题，选项里混了struct的C风格用法和C++的类风格用法。

struct ListNode { int val; ListNode* next; ListNode(int x) : val(x), next(nullptr) {} }; ListNode* head = new ListNode(1); ListNode* node2 = new ListNode(2); head->next = node2; delete node2; delete head;

关键的考点是构造函数初始化列表、->和.的区别、以及手动管理内存时的new和delete配对。有考生用C风格的方式ListNode* head = (ListNode*)malloc(sizeof(ListNode));导致后面的构造函数没有执行，val未初始化，这在笔试的代码填空里就属于必错的写法。

还有一个容易忽略的点：如果你在析构函数里delete了节点，但节点在别处又被引用，就会造成悬空指针。笔试里虽然不要求你写完整的内存管理，但选择题和简答题会专门拿这种场景来考。

3. 算法题核心战场：这些题我全部写了一遍

3.1 快速幂：几乎每年都出现的题

快速幂在网易这批笔试里作为一道独立的小题出现在选择题的算法分析部分，但它在编程题里也经常作为某个子步骤出现。快速幂解决的问题是：快速计算a^n对m取模的结果，其中n可能大到10的9次方甚至更大。

基本原理是二分：把a^n看成a^(n/2)的平方再乘以a（当n为奇数时）。这样时间复杂度从O(n)降到O(log n)。迭代写法如下：

long long fastPow(long long a, long long n, long long mod) { long long res = 1; a %= mod; while (n > 0) { if (n & 1) { res = res * a % mod; } a = a * a % mod; n >>= 1; } return res; }

笔试中常犯的错误有两个：一是忘了a %= mod这一行，导致a本身已经大于模数了，中间计算溢出；二是res = res * a % mod这行写成res *= a % mod，由于运算符优先级问题，实际结果完全不对。快速幂的复杂度是O(log n)，很多同学能看懂但手撕容易错，建议考前务必默写三遍以上。

热词里还出现了“快速幂算法c++”，说明这是笔试备考的高频搜索词。网易这批笔试虽然没有直接让写一个快速幂的完整题，但我记得选择题里有一道关于它的复杂度分析和边界条件判断，所以这个概念一定要吃透。

3.2 排序算法的考核形式：不只是写冒泡

笔试里不能直接考你“写一个快速排序”，因为所有人都背过模板。网易的方式是给一个场景，让你选最合适的排序算法。比如有一道题说：有一个几乎已经排好序的大数组，只有少数几个元素位置不对，问哪种排序算法在这种情况下表现最佳。

答案是插入排序。当数据接近有序时，插入排序的时间复杂度可以接近O(n)，而快排和归并在这种场景下反而因为递归开销和额外内存而吃亏。冒泡排序虽然也可以做类似的优化，但交换次数多，实际表现不如插入排序。

这里面暗含了一个结论：不要把算法当成背模板来看待。你应该能说出每个排序算法的适用场景、最坏情况、稳定性、空间复杂度。我当时整理了一个对比表，方便考前扫一眼：

选择题还考了“哪些排序算法是稳定的”这个经典问题。很多人把选择排序和堆排序记反，要知道选择排序虽然做的是交换，但它会打乱相同元素的相对位置，所以不稳定。

3.3 单调栈：一类题型的通用解法

第三道编程题我用的是单调栈解法。题目大意是：给定一个整数数组，对于每个元素，找出它右边第一个比它大的元素的位置。这类“下一个更大/更小元素”的题，是笔试的常客，单调栈是标准解法。

单调栈的核心思想是：维护一个栈，保持栈内元素的单调性（递增或递减）。当新元素入栈时，如果破坏了单调性，就弹出栈顶元素，并在弹出的过程中计算答案。

#include <vector> #include <stack> std::vector<int> nextGreaterElement(std::vector<int>& nums) { int n = nums.size(); std::vector<int> res(n, -1); std::stack<int> stk; // 存下标 for (int i = 0; i < n; ++i) { while (!stk.empty() && nums[stk.top()] < nums[i]) { res[stk.top()] = i; stk.pop(); } stk.push(i); } return res; }

注意几个细节：栈里存的是下标而不是值，因为计算位置差需要下标；循环结束之后栈里剩下的元素，右边没有更大的数，保持-1。用单调栈可以把时间复杂度从暴力法的O(n^2)降到O(n)，这在数据范围达到10^5时是质的差别。笔试时如果没有这个敏感性，写暴力法就很容易超时。

3.4 最小公倍数：别忽视数论基础

热词里有“n个整数的最小公倍数怎么求c++”，这八成是准备笔试的人搜出来的。笔试中真正考n个数的最小公倍数的可能性不大，但它作为一道选择题的子知识点出现过，核心解法是用辗转相除法求最大公约数（GCD），然后通过公式求最小公倍数（LCM）：

gcd(a, b) * lcm(a, b) = a * b

所以lcm(a, b) = a / gcd(a, b) * b，注意这里先除后乘，可以避免中间结果溢出。

#include <numeric> int gcd(int a, int b) { while (b != 0) { int tmp = a % b; a = b; b = tmp; } return a; } long long lcm(int a, int b) { return 1LL * a / gcd(a, b) * b; }

求n个数的最小公倍数，只需从左到右两两合并：ans = lcm(ans, nums[i])。笔试里如果出现这样的题，范围通常不会太大，用long long做中间量基本就稳了。

4. 高阶难点：多线程与内存管理的考察方式

4.1 C++多线程：笔试常考的三个点

网易这批笔试的多线程考察让我印象很深，因为不是单纯让你写一段std::thread代码，而是结合了代码填空题和简答题。总结下来有三个核心考点。

第一个是std::thread和std::mutex的基本使用。题目给了一段多个线程同时写一个共享变量的代码，让你找出问题并修复。标准解法是用std::lock_guard管理锁，确保在作用域结束后自动解锁。这里要注意std::lock_guard不能显式手动解锁，如果需要提前释放锁，要用std::unique_lock。

#include <thread> #include <mutex> std::mutex g_mtx; int counter = 0; void increment() { std::lock_guard<std::mutex> lock(g_mtx); ++counter; }

第二个是std::atomic与互斥锁的区别。对于简单的计数器，可以用std::atomic<int>替代互斥锁，性能更好。但笔试的简答题会问“什么情况下atomic不足以替代mutex”。答案是：当需要保护的不只是一个变量，而是一段复杂的状态转换逻辑时，atomic无法保证原子性，必须用锁。

第三个考点是死锁的产生条件与避免。常见的死锁是多个线程按不同顺序锁定多个互斥量。避免方法是确保所有线程都按相同的顺序加锁，或者使用std::lock一次性锁住多个互斥量。

4.2 ABA问题：从CAS到解决方案

热词里“aba问题c++”也出现了。ABA问题源于CAS（Compare-And-Swap）操作：线程1读到一个值是A，在被调度出去之前，线程2把值从A改成B又改回A，等线程1恢复运行后，CAS比较时发现值还是A，于是CAS成功，但实际上数据已经被改动过了。

笔试中这道题以选择题形式出现，问哪些方案可以解决ABA问题。正确答案是使用带版本号的引用或者使用std::atomic配合额外标记。比较经典的方案是std::atomic<std::shared_ptr<T>>配合无锁数据结构，或者使用ABA问题的经典解法——在指针中嵌入版本计数器。如果你完全不熟悉无锁编程里的CAS语义（compare_exchange_strong / compare_exchange_weak），这道题基本无从下手。

4.3 设计模式与回调函数：面向对象细节

网易这批笔试的设计模式题比我想象中要多一些。有一道选择题是给出一段代码，问它体现了哪种设计模式。代码里有一个抽象基类和多个派生类，然后在运行期根据条件动态创建不同派生类的对象——这显然是工厂模式。但要注意选项里也混了策略模式和观察者模式，如果只记模式名字而不看具体代码结构，很容易错。

回调函数也是C++开发笔试的高频内容。笔试考回调函数的本质是函数指针的应用场景。C++11之后，更推荐用std::function和lambda表达式来代替裸函数指针：

#include <functional> #include <vector> void process(std::vector<int>& data, std::function<int(int)> callback) { for (auto& x : data) { x = callback(x); } } int main() { std::vector<int> data = {1, 2, 3}; process(data, [](int x) { return x * 2; }); return 0; }

这里要特别注意lambda的捕获列表，按值捕获和按引用捕获在使用时完全不同，笔试很喜欢在代码阅读题里考察[=]、[&]的差异以及捕获的变量在lambda生命周期中的有效性。

5. 编程实战环节：如何稳定拿分

5.1 在线笔试环境的特点和应对

网易的编程题用的是牛客网或者类似的在线OJ系统，所以有几个点要提前适应。

首先，编译器版本和本地不一样。笔试环境默认是C++14或C++17，但个别公司也会用C++11。如果你在本地VS Code配的C++环境是最新的g++，用了很多C++20的特性，比如std::span、概念（concepts），到了笔试环境可能编译不过。稳妥起见，笔试前把代码控制在C++11规范内，最多用C++14。

另外，在线OJ的编译选项通常比较严格，Warning可能不当作错误，但一些未定义行为（比如整数溢出、越界访问）会直接导致结果错误，而且不容易排查。比如int类型在计算a * b时溢出，本地跑可能没问题是因为编译器优化，在线环境就可能结果不对。做算法题涉及乘法运算时，建议直接用long long。

5.2 输入输出处理的常见坑

笔试编程题是ACM模式，输入输出要自己处理。常见坑有三个：

第一个是数组形式不固定。有的题输入是一行空格分隔的数字，有的题是每个数字占一行，还有的题直接给[1,2,3]这种带方括号和逗号的格式。你需要根据输入描述做不同的解析。

#include <iostream> #include <sstream> #include <vector> int main() { std::string line; std::getline(std::cin, line); std::istringstream iss(line); std::vector<int> nums; int x; while (iss >> x) { nums.push_back(x); } return 0; }

第二个是输出格式要求。很多题要求数字之间用空格分隔、末尾不能有多余空格。一个通用技巧是：遍历输出，如果不是第一个元素就先输出一个空格，再输出当前元素，这样永远不会有末尾空格。

第三个是while (std::cin >> n)这种处理多组输入的方式。有些题输入是多组测试用例，没有明确告诉你有多少组，这时要用while (std::cin >> ...)的写法，读到文件结束自动退出。如果你用if读取，只能处理单组，直接凉了一半。

5.3 减少运行时间的实战技巧

热词里有一条“c++怎么只能加代码的情况下减少运行时间”，这个说得很直白，就是笔试里代码不让改，只能加，怎么优化运行时间。我有几个实际用过的招。

第一招是去同步。如果代码里没有输入输出交叉的场景，在main函数开头加这两行：

std::ios::sync_with_stdio(false); std::cin.tie(nullptr);

这两行能显著提高cin/cout的运行速度。原理是关闭C++的输入输出流和C标准输入输出库的同步，避免每次cin都同步到scanf。代价是你不能在代码里混用printf和cout，否则输出顺序可能错乱。

第二招是减少中间对象的拷贝。在循环里频繁构造string、vector时，改用reserve预留空间，避免多次扩容和复制。例如：

std::vector<int> ans; ans.reserve(n); // 提前知道最多n个元素

第三招是尽量使用++i而不是i++。对于int类型，两者在现代编译器下基本没有区别，但对于迭代器类型，i++会返回旧值，需要构造一个临时对象，开销更大。笔试代码里养成写++i的习惯，没有坏处。

第四招是关注时间复杂度。比如要多次查找元素是否在集合中，用std::unordered_set的平均O(1)查找，比std::set的O(log n)更快。此外在穷举子集和排列时，优先考虑剪枝，而不是强行优化某个函数的常量因子。

6. 避坑实录：这批笔试中的典型问题

6.1 编译不过的三大原因

笔试中如果提交显示编译错误，最常见的三个原因我来总结一下。

第一个是int main()写成了void main()。虽然有些编译器放宽了这个要求，但OJ环境通常严格检查返回值。

第二个是结构体定义末尾忘了加分号：

struct Node { int val; Node* next; }; // 这个分号千万不能丢

第三个是被面试官坑到的：代码里用了C++11的nullptr，但写了NULL也能过，可有些编译环境会报NULL未定义。稳妥起见，C++代码里一律用nullptr，如果你需要兼容C，才使用NULL或0。

6.2 超时的排查思路

如果你提交后显示“运行超时”，代码逻辑可能是对的，但效率不达标。最常见的超时原因是暴力算法。比如找“下一个更大元素”，你用两重循环，数据范围一大必超时，这时就该换单调栈。再比如计算斐波那契数列，递归写法在n很大时直接超时，要改用递推或矩阵快速幂。

我的排查思路是：先看数据范围。如果n是10^5级别，那O(n^2)的算法大概率超时，O(n log n)或者O(n)才行。如果n是10^3级别，O(n^2)可能还可以。如果n是10^9级别，那必须用O(log n)的算法。这个敏感度要在平时刷题时专门训练。

另一个容易忽略的超时原因是STL容器的误用。比如在std::vector的头部频繁insert，每次insert都是O(n)复杂度；如果插入次数是n，整体就是O(n^2)。这种场景应该改用std::deque或者std::list。还有std::unordered_map在极端哈希冲突情况下可能退化到O(n)，笔试如果故意构造数据，会卡这种点。一般来说用std::map（红黑树实现）更稳定，虽然单次操作是O(log n)，但不容易被卡。

6.3 我踩过的几个具体坑

我在这批笔试里踩了一个很典型的坑：编程题第一题，题目要求先读入数组长度n，接下来一行是n个整数。我用cin >> n读完之后，又用getline读第二行，结果getline读到了一个空字符串。原因就是上一节提到的，cin >> n之后缓冲区里残留了一个换行符，getline直接把它消费掉了。后面所有数据全部错位。最后我用cin.ignore()解决了这个问题。这种问题如果你之前没遇到过，考场上真的会浪费很长时间。

还有一个坑是：我提交了一道题的代码，本地测试全部通过，但OJ判题错误。后来发现是数组越界。代码里一个循环访问了nums[i + 1]，当i等于n-1时越界了。本地跑的时候因为是POD类型且内存布局恰好没报错，但OJ环境内存布局不同，就出问题了。从那以后，凡是涉及i + 1、i - 1的访问，我都会先检查边界条件，这个习惯在笔试里救了我好几次。

另外，笔试期间尽量少切换编译器环境。我记得考场上有同学一直用VS Code的Code Runner在本地跑测试，但把代码复制到OJ上去之后，因为OJ用的g++版本不支持某些扩展语法，编译就出错了。我个人的经验是：平时练习就在一个跟OJ相近的在线平台上跑，比如你可以在本机装一个较新版本的MinGW-w64，用g++ -std=c++17 -O2编译你的代码，这样最接近笔试环境。VS Code里配置C/C++环境的时候，把编译命令显式加上-std=c++17，不要用默认。

6.4 CHAT记录：笔试后和朋友的讨论

考完试那天晚上，我和几个朋友在群里对了一下答案，发现大家错得比较集中的地方是选择题里关于虚函数和移动语义的两道题。

一道题是：基类析构函数不是虚函数，派生类对象通过基类指针delete，会发生什么。答案是未定义行为——通常只会调用基类析构函数，派生类部分不会被正确释放，导致资源泄漏。这个知识点考察的是“当你把基类的析构函数标记为virtual时，通过基类指针删除派生类对象才会正确调用派生类析构函数”这个规则。

另一道题：std::move到底做了什么。很多人以为std::move是移动数据的函数，实际上它只是一个转换函数，把左值强制转换为右值引用。真正发生移动构造或移动赋值，是在接收方处理这个右值引用的时候。如果接收方没有实现移动构造，编译器可能会退化为拷贝构造。理解了这一点，你才能真正理解移动语义的限制条件。

这两道题都属于“平时知道，但不深究”的知识点。网易正好就考这些，说明它对C++基础的要求已经超过了“会用库函数”的层面，而是真的考察你对语言机制的理解。

6.5 笔试后需要继续补强的地方

复盘完这批笔试，我有几个方向是明确需要继续投入时间的。第一个是并发编程的实践经验。选择题考了std::atomic和std::mutex的区别，我虽然能选对，但要在代码里写出一个无锁的数据结构，我还需要大量练习。第二个是泛型编程和模板元编程的细节，笔试没细考，但面试环节很可能会追着问。第三个是操作系统和计算机网络的基础，网易这批笔试的选择题也涉及了一部分，虽然占比不高，但不能完全没有概念。

另外，如果你正在准备校招，有个实操建议：把每一家公司笔试做错的题都整理到一个文档里，标注错误原因和正确思路。我自己有一个Excel表，按公司、题型、知识点、错误原因、正确解法五列来记，到了面试前集中过一遍，效果非常好。笔试不是考完就结束了，它其实是面试前最高效的模拟训练。

7. 一些笔试通用的实操心得

最后还是忍不住想再多唠叨几句，因为这些都是我亲手踩出来的经验。

第一个心得是：笔试前一定要花十分钟把所有模板代码过一遍。我指的模板不是算法模板，而是输入输出模板、快速幂、最大公约数与最小公倍数、并查集、前缀和与差分、单调栈和队列。这些都是笔试题里最容易出现的骨架，过一遍就能让肌肉记忆恢复。

第二个心得是：如果一道题五分钟没有思路，直接看数据范围。数据范围会提示你该用什么算法。看到n小于等于20，优先考虑状态压缩或者回溯；看到n小于等于1000，可以接受O(n^2)；看到n小于等于10^5，必须用O(n log n)或更优解法。

第三个心得是：提交前留出五分钟检查。至少检查一遍有没有写return 0;、有没有把输出写错变量、有没有在注释里留下中文标点导致编译错误。这些小问题在紧张状态下特别容易发生，别让到手的分飞了。

第四个心得是：不要把某一家公司笔试的失败看得太重。校招是长跑，拿到offer的人通常也不是每一家都过了笔试的。关键是善于复盘和吸收，把每次笔试当成一次免费的全真模拟。我后来拿到网易的面试邀请，就是因为在复盘时把一些知识盲区及时补齐了，在面试环节被问到的时候能讲出细节。