深信服科技股份有限公司校招技术岗面试经验——求职精灵（finsight.work）

回答框架：先点名封装、继承、多态，再按「是什么 → 解决什么问题 → 一个例子」逐条展开，最后收一句三者的关系。

1. 封装：把数据和对数据的操作包在类里，用 public / protected / private 控制可见性。它解决的是「状态被随意修改」的问题，外部只能通过接口改状态，类内部可以维护不变式。比如账户类把余额设为 private，只暴露 deposit / withdraw 并在内部校验金额。
2. 继承：子类复用父类的属性和方法，可以扩展新成员或重写虚函数。它解决代码复用和层次抽象，但继承是强耦合，工程上一般讲「组合优先于继承」。
3. 多态：同一个接口在不同对象上有不同实现。编译期多态靠函数重载和模板；运行期多态靠虚函数表，基类指针指向派生类对象时，调用虚函数会按对象的实际类型分派。

收尾可以补一句「封装是基础，继承是手段，多态是目的」，并主动提一句：基类析构函数要写成 virtual，否则用基类指针 delete 派生类对象时析构不完整。

回答框架：不要报菜名，挑五六个真正用过的特性，每个说清「解决什么问题 + 一行示例」。

1. nullptr：NULL 本质是整数 0，重载时会被当成 int，nullptr 有独立的 std::nullptr_t 类型，消除了指针与整数的二义性。
2. auto / decltype：编译期类型推导，写迭代器和长模板类型时省事，但不要用在对外接口上，可读性会下降。
3. 范围 for：for (auto& x : v) 直接遍历容器，配合引用避免拷贝。
4. Lambda：匿名函数，常用于排序规则和回调，捕获列表要分清值捕获和引用捕获的生命周期。
5. 右值引用与移动语义：std::move 把资源所有权转走，配合移动构造避免深拷贝，std::forward 用于完美转发。
6. 智能指针：unique_ptr / shared_ptr 把 RAII 落到实处，替代手写 new / delete。

最后补一句：C++11 之后还有 14/17/20，结构化绑定、optional、string_view 在日常代码里也很常见，说明自己跟得上标准演进，而不是停在课本。

回答框架：先说冲突的本质，再按开放定址、链地址、再散列三类讲，最后点出工业界怎么选。
冲突的本质是不同 key 经哈希函数映射到了同一个桶。常见做法有四类：

1. 线性探测：冲突后依次看下一个槽位，到表尾折返。实现简单、缓存友好，但容易形成连续聚集，删除还要用墓碑标记。
2. 二次探测：步长取 1²、2²、3²……，缓解一次聚集，仍可能出现二次聚集，装填因子一般控制在 0.5 左右。
3. 拉链法：每个桶挂一条链表，冲突元素挂到链上。实现直观、删除方便，是 std::unordered_map 的典型做法；链太长时会转成红黑树，把最坏查找从 O(n) 降到 O(log n)。
4. 再散列：换一个哈希函数重新计算，直到找到空位，计算开销更大，一般作为兜底。

收尾可以说：工程上还会配合扩容，负载因子超过阈值就 rehash，再配一个分布均匀的哈希函数，单靠某一种冲突处理解决不了性能问题。

回答框架：先给结论，再讲运算符优先级，最后各给一个使用场景。
关键在优先级：[] 高于 *，有括号先看括号。

• int *p[10] 是指针数组：p 先和 [10] 结合，是一个长度为 10 的数组，每个元素是 int*。适合存一组同类型的指针，比如十个字符串的首地址。
• int (*p)[10] 是数组指针：括号让 p 先和 * 结合，p 是一个指针，指向「含 10 个 int 的数组」。它常用于二维数组传参，作为形参时 p++ 会一次跳过一整行。

追问预警：可能会继续问 int *(*p)[10]，那是「指向指针数组的指针」，按同样的优先级一层层剥即可。答题时最好在纸上画一下结合顺序，比背结论更可信，也能顺带说明自己理解的是声明语法而不是死记。

回答框架：按管理方式、分配效率、空间大小、碎片、生长方向五个维度对比，最后落到「什么时候该用堆」。

1. 管理方式：栈由编译器自动管理，函数返回就释放；堆由程序员通过 new / delete 或 malloc / free 手动管理，忘记释放就是内存泄漏。
2. 分配机制：栈是连续内存，移动栈顶指针即可，剩余空间不够就栈溢出；堆基于空闲链表找合适的内存块，分配前要查找、可能触发系统调用。
3. 空间大小：栈一般很小，Windows 默认 1～2 MB，Linux 常见 8 MB；堆受虚拟地址空间限制，可以申请到很大。
4. 碎片：栈先进后出、进出一一对应，不产生碎片；堆频繁申请释放会产生外部碎片。
5. 生长方向与效率：栈通常向低地址生长，有专用寄存器和指令支持，效率高；堆向高地址生长，机制复杂，效率低。

收尾补一句：对象能在栈上就别放堆上，RAII 和智能指针的价值就是把「手动释放」变成「作用域结束自动释放」。

回答框架：定义 → 举例 → 两种判断代码 → 一句工程背景。
定义：多字节数据在内存里的字节顺序。大端把高字节放在低地址，0x12345678 存成 12 34 56 78；小端把低字节放在低地址，存成 78 56 34 12。x86 和多数 ARM 默认小端，网络字节序规定为大端，所以 socket 编程要做 htonl / ntohl 转换。
判断方法一：取 int 的地址转成 char*，看第一个字节。

int a = 0x12345678;
char c = *(char*)&a;
// c == 0x12 为大端，c == 0x78 为小端

方法二：用 union 让 int 和 char 共享同一块内存。

union { int a; char c; } u;
u.a = 0x12345678;
// u.c == 0x12 为大端，0x78 为小端

注意：如果题目给的示例是 0x1234 这种两字节数，要先说明自己按 4 字节 int 讨论，避免和示例对不上。收尾补一句：判断字节序的意义在跨平台通信、协议解析和二进制文件读写，不是纯八股。

回答框架：从确认重传、校验、排序、流量控制、拥塞控制五个机制展开，每个说清「解决什么问题」，最后和 UDP 对比收尾。

1. 确认与重传：接收方收到报文回 ACK，发送方启动超时计时器，超时未收到确认就重传；还有快速重传，收到三个重复 ACK 立即重发，不必等超时。
2. 数据校验：报文头带校验和，接收方校验失败直接丢弃，让发送方重传。
3. 分片与排序：按 MSS 分段，接收方缓存乱序到达的段，按序号重组后交给应用层；重复的段会被去重。
4. 流量控制：基于滑动窗口，接收方通过窗口字段告知还能收多少，避免发送太快把接收缓冲区打满。
5. 拥塞控制：慢启动、拥塞避免、快重传、快恢复，根据网络状况调整拥塞窗口，防止把链路压垮。

收尾对比一句：UDP 不建连接、不确认、不重传，所以快但不可靠，音视频和游戏这类能容忍丢包的场景更常用。如果追问「TCP 一定可靠吗」，要补一句：它保证的是有序、无差错、不重复的字节流，不保证应用层一定处理成功。

回答框架：先给存储位置，再补安全性、容量、生命周期三点差异，最后说实际系统里怎么配合。

1. Cookie 存在客户端浏览器，是服务器通过 Set-Cookie 下发的小段文本，单个域名下一般限制在 4 KB 左右，可以设置过期时间、Domain、Path、HttpOnly 和 Secure。它明文可见，容易被篡改，所以不能放敏感信息。
2. Session 存在服务端，可以是内存、数据库或 Redis，浏览器只保存一个 SessionID，通常也放在 Cookie 里传回来。数据在服务端，容量不受 4 KB 限制，安全性更高。
3. 实际用法：登录成功后服务端生成 SessionID，写入 Redis 并设置过期时间，客户端后续请求带上它；分布式部署时要保证 Session 共享，否则换一台机器就掉登录。

收尾补一句：现在更常见的是 Token / JWT，把状态放到客户端签名里，服务端不存 Session，扩展性更好，但注销和续期要另外设计。

回答框架：先复述需求「按性别分组，统计人数和平均分」，再写语句，最后解释每个关键字的作用与边界。

SELECT sex,
       COUNT(*)      AS total_students,
       AVG(score)    AS average_score
FROM grades
WHERE sex IN ('male', 'female')
GROUP BY sex;

要点：

1. GROUP BY 按 sex 分组，SELECT 里只能出现分组列和聚合函数，否则语义不明确。
2. COUNT(*) 统计行数，如果成绩可能为 NULL，用 COUNT(score) 只统计有成绩的记录。
3. AVG 会自动忽略 NULL，需要把空成绩当 0 参与平均时要写 AVG(COALESCE(score,0))。
4. WHERE 在分组前过滤，如果只想看平均分高于 80 的组，要用 HAVING AVG(score) > 80。

追问预警：面试官可能加一个「按班级和性别两级分组」，那就是 GROUP BY class_id, sex；也可能问去重人数，用 COUNT(DISTINCT student_id)。写之前先确认字段名和是否有 NULL，比直接背模板更稳。

回答框架：先说分治思路和复杂度，再写分区函数，最后讲边界与优化。
思路：选一个基准值，把小于它的放左边、大于它的放右边，基准归位后递归处理左右两段。平均时间复杂度 O(n log n)，最坏 O(n²)，空间是递归栈的 O(log n)。

int partition(vector<int>& a, int low, int high) {
    int pivot = a[high];
    int i = low - 1;
    for (int j = low; j < high; ++j)
        if (a[j] <= pivot) swap(a[++i], a[j]);
    swap(a[i + 1], a[high]);
    return i + 1;
}
void quickSort(vector<int>& a, int low, int high) {
    if (low >= high) return;
    int p = partition(a, low, high);
    quickSort(a, low, p - 1);
    quickSort(a, p + 1, high);
}

要主动说明的点：

1. 边界：low >= high 直接返回，空数组和单元素不会越界。
2. 最坏情况：数组已经有序且固定取最后一个元素做基准，会退化成 O(n²)，可以随机选基准或三数取中。
3. 稳定性：快排不稳定，需要稳定排序时用归并。
4. 工程优化：小区间（比如长度小于 16）改用插入排序，递归深度过大时切堆排序。

回答框架：先说快慢指针的直觉，再写代码，最后补边界和追问。
思路：慢指针每次走一步，快指针每次走两步。如果链表有环，两个指针一定会在环内相遇；如果无环，快指针先到达 NULL。时间 O(n)，空间 O(1)。

bool hasCycle(ListNode* head) {
    if (!head || !head->next) return false;
    ListNode* slow = head;
    ListNode* fast = head->next;
    while (slow != fast) {
        if (!fast || !fast->next) return false;
        slow = slow->next;
        fast = fast->next->next;
    }
    return true;
}

边界与追问：

1. 空链表、单节点直接返回 false，否则 fast->next 会解引用空指针。
2. 追问「怎么找环的入口」：相遇后把一个指针放回头节点，两个指针都每次走一步，再次相遇的位置就是入口。
3. 追问「环的长度」：相遇后继续走，记录回到原点的步数。
4. 追问「为什么一定相遇」：快指针每轮比慢指针多走一步，在环内相当于逐格逼近，不会跨过去。

说复杂度时要顺带说空间 O(1)，这是相比哈希表标记法的优势。