深信服 25 届技术岗一面面经：C++、计网、操作系统核心考点解析

C++ 面向对象的三大特性

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

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

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

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（单向链表，节省内存）等。

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

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

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

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

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

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

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

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

堆和栈的区别

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

核心回答（表格梳理）：

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

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

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

核心回答：

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）判断（利用 union 成员共享内存的特性）

   #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;
   }
   

快速排序（QuickSort）

回答思路：先说明快排的核心思想（分治），再结合代码解释分区（partition）和递归过程，强调时间复杂度。

核心回答：
快速排序是一种高效的基于分治思想的排序算法，平均时间复杂度为 O(N log N)。

1. 核心思想：

   • 选择基准（Pivot）：从数组中选择一个元素作为基准。
   • 分区（Partition）：重新排列数组，将所有小于基准的元素移到基准的左边，所有大于基准的元素移到基准的右边。
   • 递归：对基准左右两边的子数组递归地进行快速排序，直到子数组只有一个元素或为空（low >= high 时终止递归）。

2. 代码实现：

   #include <iostream>
   #include <vector>
   #include <algorithm> // For std::swap
   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) { // 至少两个元素才排序
           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 << " ";
       cout << endl; // 输出：1 1 2 3 4 5 6 9
       return 0;
   }
   

判断链表是否有环

回答思路：说明快慢指针法（Floyd 判圈算法）的核心思想，结合代码解释指针移动和判断条件。

核心回答：
判断链表是否有环，最常用的方法是快慢指针法（Floyd 判圈算法）。

1. 核心思想：

   • 设置两个指针 slow 和 fast，slow 每次移动一步，fast 每次移动两步。
   • 如果链表无环，fast 指针最终会到达链表末尾（NULL）。
   • 如果链表有环，fast 指针最终会追上 slow 指针，两者相遇。

2. 代码实现：

   #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() {
       // 构造有环链表：1->2->3->4->2
       ListNode* head = new ListNode(1);
       head->next = new ListNode(2);
       head->next->next = new ListNode(3);
       head->next->next->next = new ListNode(4);
       head->next->next->next->next = head->next; // 环指向2
   
       cout << (hasCycle(head) ? "有环" : "无环") << endl; // 输出：有环
   
       // 构造无环链表：1->2->3->4
       ListNode* head2 = new ListNode(1);
       head2->next = new ListNode(2);
       head2->next->next = new ListNode(3);
       head2->next->next->next = new ListNode(4);
       cout << (hasCycle(head2) ? "有环" : "无环") << endl; // 输出：无环
   
       return 0;
   }
   

### 总结

<strong>关键点回顾</strong>

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