25届校招深信服技术岗一面面经｜基础为王，附核心考点+详细回答思路

25 届校招深信服技术岗一面面经｜基础为王，附核心考点 + 详细回答思路

本次分享一位 25 届应届生的深信服技术岗一面面经，面试整体难度偏基础，核心考察计算机核心基础与算法能力，希望能为同届校招同学提供参考。

一、学生个人情况介绍

本次分享的面经来自 25 届应届毕业生，应聘深信服校招技术岗，本次为一面环节。该同学反馈面试体验良好，无超纲冷门考点，考察重点集中在 C++ 编程语言、计算机网络、操作系统、SQL 基础及经典手撕算法题，是典型的技术岗基础能力验证型面试。

二、面试企业和部门介绍

1. 企业介绍

深信服科技股份有限公司是国内头部的网络安全、云计算与 IT 基础设施解决方案提供商，业务覆盖政企、金融、教育、医疗等多个领域。校招技术岗招聘中，深信服高度重视候选人的计算机基础功底（网络、操作系统）、编程语言实战能力（以 C/C++ 为主）和算法思维，核心考察“基础是否扎实”而非“冷门知识储备”。

2. 面试部门

本次面试为深信服通用技术岗一面，未明确细分具体业务部门，所有问题均围绕通用技术能力展开，无针对性的业务场景问题，聚焦基础能力验证。

三、面试核心内容与回答思路

面试内容分为五大模块，以下为每个问题的提问方向、详细回答思路及核心要点：

模块一：C++（核心编程语言考察）

C++ 是本次面试的重点考察方向，问题均为技术岗高频基础考点，注重“理解原理 + 能落地解释”。

问题 1 介绍 C++ 面向对象的三大特性

回答思路： 先总述三大特性名称，再分别拆解每个特性的“定义 + 核心价值 + 通俗示例”，让回答有层次、不空洞。

核心回答： C++ 面向对象的三大核心特性是继承、封装、多态，三者共同支撑“代码复用、抽象化、逻辑灵活”的编程思想：

• 继承： 让子类获取父类的属性和方法，无需重复编写原有代码，同时可扩展新功能（如“动物”父类定义通用行为，“猫/狗”子类继承后扩展“叫”的具体逻辑）；
• 封装： 将事物的属性和方法抽象为类，通过 public/private/protected 控制访问权限，对不可信的外部隐藏核心数据（如类的私有成员仅能被内部方法修改，避免外部误操作）；
• 多态： 同一消息发送给不同对象，执行不同逻辑——编译时多态通过函数重载实现，运行时多态通过虚函数/纯虚函数实现（如父类指针指向子类对象，调用同一方法时执行子类逻辑）。

问题 2 C++ 11 有哪些新特性？

回答思路： 优先列举“高频实用”的新特性，每个特性说明“解决的问题 + 简单使用示例”，避免仅罗列名词。

核心回答： C++11 是 C++ 的里程碑版本，新增特性大幅提升开发效率，核心常用的有：

• nullptr： 替代原有 NULL（NULL 本质是 0，易引发指针/整数类型混淆），专门表示空指针，类型更安全；
• 类型推导关键字： auto 让编译器自动推导变量类型（如 auto i = 10; 推导为 int），decltype 推导表达式类型，减少复杂类型的冗余书写；
• 基于范围的 for 循环： 简化容器遍历，如 for(auto& i : res){} 可直接遍历数组/容器，无需手动控制下标；
• Lambda 表达式： 支持定义匿名函数，适用于临时简单逻辑（如容器排序时直接写排序规则）；
• 右值引用与 move 语义： 解决临时对象的拷贝效率问题，通过 std::move 实现资源转移，减少内存拷贝；
• 其他： 类/结构体初始化列表（struct A{int a;}; A a{10};）、std::forward_list（单向链表，节省内存）等。

问题 3 hashtable 中解决冲突有哪些方法？

回答思路： 先说明哈希冲突的本质（不同 key 映射到同一地址），再分点介绍每种方法的“核心逻辑 + 优缺点”，突出工业界常用方案。

核心回答： 哈希冲突是“不同 key 经哈希函数计算后得到同一数组下标”，常见解决方法有 4 种：

• 线性探测： 冲突时向后依次找空位（表尾则回到表头），实现简单但易出现“连续聚集”，降低查找效率；
• 开链法（拉链法）： 每个哈希位置维护一个链表，冲突的 key 插入对应链表，无聚集问题，是工业界主流方案（如 C++ unordered_map 底层实现）；
• 再散列： 冲突时用另一哈希函数重新计算地址，直到找到空位，避免聚集但增加哈希计算开销；
• 二次探测： 冲突时按平方步长（1²、2²、3²…）找空位，相比线性探测减少聚集，若步长为随机数则为伪随机探测。

**问题 4 区分 int p[10] 和 int (p)[10]（指针数组 vs 数组指针）

回答思路： 结合“运算符优先级”拆解语法，明确“核心是数组”还是“核心是指针”，配合通俗解释。

核心回答： 区分的关键是 [] 优先级高于 *，核心看“本质是数组还是指针”：

• int p[10]： 指针数组——先构成数组 p[10]，数组的每个元素是 int 类型（指向 int 的指针），核心是“数组”；
• *int (p)[10]： 数组指针——() 提升 * 优先级，先构成指针 p，该指针指向“包含 10 个 int 元素的数组”，核心是“指针”。

模块二：操作系统

操作系统考察聚焦“内存管理”和“数据存储”，均为技术岗必考点，注重“对比记忆 + 原理理解”。

问题 5 堆和栈的区别

回答思路： 从“管理方式、内存机制、空间大小、碎片、生长方向、分配方式、效率”7 个维度对比，结合通俗解释辅助理解。

核心回答（表格梳理）：

对比维度	堆	栈
管理方式	程序员手动控制（new/delete），易内存泄漏	编译器自动管理，出作用域自动释放
内存管理机制	基于空闲链表分配，找首个足够大的内存块	连续内存，剩余空间足够则分配，否则栈溢出
空间大小	不连续，受虚拟内存限制（32 位系统理论 4G），空间大且灵活	连续，大小固定（Windows 默认 2M），空间小
碎片问题	频繁 new/delete 易产生内存碎片，降低效率	先进后出，进出一一对应，无碎片
生长方向	向上（高地址方向）	向下（低地址方向）
分配方式	仅动态分配	静态分配（局部变量）+ 动态分配（alloca 函数），均自动释放
分配效率	函数库实现，机制复杂，效率低	系统底层支持（专用寄存器/指令），效率高

问题 6 大小端存储是什么意思？如何区分？

回答思路： 先定义大小端，结合数值示例说明存储方式，再给出两种可运行的代码判断方法，解释核心原理。

核心回答：

1. 大小端定义

大小端是多字节数据的内存存储顺序，核心区别：

• 大端存储： 高字节存低地址（符合人类阅读习惯，如 0x12345678，低地址存 0x12）；
• 小端存储： 低字节存低地址（主流操作系统采用，如 0x12345678，低地址存 0x78）；
• 注：网络传输用大端，Socket 编程需将主机小端转为网络大端。

2. 代码判断方法

方法一：强制类型转换（利用 int 转 char 仅保留低地址字节）

#include <iostream>
using namespace std;
int main() {
 int a = 0x1234;
 char c = (char)a; // 仅保留低地址字节
 if (c == 0x12) cout << "大端" << endl;
 else cout << "小端" << endl;
 return 0;
}

方法二：联合体（union 共享内存，char 仅占用 int 的低地址部分）

#include <iostream>
using namespace std;
union endian {
 int a; // 4字节，与ch共享内存
 char ch; // 仅占用a的低地址部分
};
int main() {
 endian val;
 val.a = 0x1234;
 if (val.ch == 0x12) cout << "大端" << endl;
 else cout << "小端" << endl;
 return 0;
}

模块三：计算机网络

计算机网络考察聚焦“传输层协议”和“网络层协议”，均为高频考点，注重“协议对比 + 核心机制”。

问题 7 TCP 和 UDP 的区别

回答思路： 从“连接性、可靠性、传输方式、效率、应用场景”5 个维度对比，每个维度用一句话概括核心差异。

核心回答：

对比维度	TCP	UDP
连接性	面向连接（三次握手建立连接，四次挥手释放连接）	无连接（直接发送数据，无需建立连接）
可靠性	可靠传输（确认重传、流量控制、拥塞控制）	不可靠（尽最大努力交付，不保证数据到达）
传输方式	面向字节流（数据无边界，需应用层处理粘包）	面向报文（保留报文边界，一次发送一个完整报文）
效率	较低（头部开销大，20 字节，且需维护连接状态）	较高（头部开销小，8 字节，无连接维护）
应用场景	文件传输（FTP）、网页浏览（HTTP）、邮件（SMTP）	实时通信（视频/语音通话）、直播、DNS 查询

问题 8 从输入 URL 到页面展示的完整过程

回答思路： 按时间线分阶段描述，每个阶段说明“核心动作 + 涉及协议”，让回答有逻辑、不遗漏关键步骤。

核心回答： 从输入 URL 到页面展示，共经历 6 个核心阶段：

1. DNS 解析： 浏览器缓存 → 系统缓存 → 路由器缓存 → ISP 缓存 → 根域名服务器，递归/迭代查询获取目标 IP（涉及 DNS 协议）；
2. TCP 连接： 客户端与服务器三次握手建立连接（涉及 TCP 协议）；
3. 发送 HTTP 请求： 浏览器构建 HTTP 请求报文（含请求行、请求头、请求体），通过 TCP 连接发送（涉及 HTTP 协议）；
4. 服务器处理请求并返回响应： 服务器处理请求（如查询数据库、生成动态页面），返回 HTTP 响应报文（含状态码、响应头、响应体）；
5. 浏览器解析渲染页面： 解析 HTML 构建 DOM 树，解析 CSS 构建 CSSOM 树，合并为渲染树，计算布局并绘制页面；
6. 断开连接： 数据传输完毕，四次挥手释放 TCP 连接（涉及 TCP 协议）。

模块四：SQL 基础

SQL 考察聚焦“多表查询”和“聚合函数”，为技术岗通用技能，注重“语法正确 + 逻辑清晰”。

问题 9 编写 SQL 查询：查询每个部门工资最高的员工

回答思路： 先明确需求（按部门分组，取每组工资最大值），再给出两种常见写法（子查询 + 窗口函数），并说明各自适用场景。

核心回答： 假设表结构为 employee(id, name, salary, department_id)，部门表为 department(id, name)。

方法一：子查询（通用写法，兼容性好）

SELECT d.name AS department_name, e.name AS employee_name, e.salary
FROM employee e
JOIN department d ON e.department_id = d.id
WHERE e.salary = (
 SELECT MAX(salary)
 FROM employee
 WHERE department_id = e.department_id
);

方法二：窗口函数（MySQL 8.0+ / PostgreSQL 支持，性能更优）

SELECT department_name, employee_name, salary
FROM (
 SELECT d.name AS department_name, e.name AS employee_name, e.salary,
 RANK() OVER (PARTITION BY e.department_id ORDER BY e.salary DESC) AS rnk
 FROM employee e
 JOIN department d ON e.department_id = d.id
) ranked
WHERE rnk = 1;

模块五：手撕算法

算法考察聚焦“排序”和“链表”，均为经典高频题，注重“思路清晰 + 代码规范 + 边界处理”。

问题 10 手撕快速排序

回答思路： 先说明快速排序的核心思想（分治 + 分区），再给出完整代码，包含分区函数和递归函数，并强调边界条件。

核心回答： 快速排序的核心思想是“选基准、分区、递归”，时间复杂度平均 O(n log n)，最坏 O(n²)。

完整代码：

#include <iostream>
#include <vector>
using namespace std;

// 分区函数：返回基准值的正确下标
int partition(vector<int>& nums, int low, int high) {
 int pivot = nums[high]; // 选最右元素为基准
 int i = low - 1; // 小于基准的区域边界
 for (int j = low; j < high; j++) {
 if (nums[j] < pivot) {
 i++;
 swap(nums[i], nums[j]);
 }
 }
 swap(nums[i + 1], nums[high]); // 将基准放到正确位置
 return i + 1;
}

// 快速排序递归函数
void quickSort(vector<int>& nums, int low, int high) {
 if (low < high) { // 区间长度 > 1 才排序
 int pi = partition(nums, low, high);
 quickSort(nums, low, pi - 1); // 排序左子数组
 quickSort(nums, pi + 1, high); // 排序右子数组
 }
}

// 测试示例
int main() {
 vector<int> nums = {3, 1, 4, 1, 5, 9, 2, 6};
 quickSort(nums, 0, nums.size() - 1);
 for (int num : nums) cout << num << " ";
 return 0;
}

问题 11 判断链表是否有环

回答思路： 先说明核心思路（快慢指针法），再给出完整代码，包含边界条件处理和相遇判断。

核心回答： 使用快慢指针法，快指针每次走 2 步，慢指针每次走 1 步，若存在环则两指针必相遇。

完整代码：

#include <iostream>
using namespace std;

// 链表节点定义
struct ListNode {
 int val;
 ListNode *next;
 ListNode(int x) : val(x), next(NULL) {}
};

// 判断链表是否有环
bool hasCycle(ListNode *head) {
 // 边界条件：空链表/单节点无环
 if (head == NULL || head->next == NULL) return false;
 ListNode* slow = head; // 慢指针：走1步
 ListNode* fast = head->next; // 快指针：走2步
 while (slow != fast) {
 if (fast == NULL || fast->next == NULL) return false; // 快指针到尾，无环
 slow = slow->next;
 fast = fast->next->next;
 }
 return true; // 相遇，有环
}

// 测试示例
int main() {
 // 构造

## 四、总结

**关键点回顾**

- **面试难度**：深信服技术岗一面以基础为主，无偏题怪题，核心考察 C++、操作系统、计算机网络三大核心学科，SQL 和算法为常规经典题。
- **备考重点**：编程语言聚焦 C++ 面向对象、指针、C++11 特性，基础学科注重 “原理理解” 而非死记硬背，算法掌握快排、链表判环等经典题。
- **回答技巧**：回答问题时先总述核心要点，再分点拆解，结合 “通俗示例 / 应用场景” 说明，避免仅罗列知识点。