1. 多态（静态多态 vs 动态多态、虚函数、虚函数表 vtable、虚指针 vptr）#

• 静态多态（编译期多态）：函数重载（Overload）与模板（Template）。在编译期通过名字修饰（Name Mangling）和模板实例化确定具体调用的函数地址，零运行时开销，支持内联优化。
• 动态多态（运行期多态）：基于虚函数（virtual）。当类中含有虚函数时，编译器为该类生成一张虚函数表（vtable，只读数据段），表中按声明顺序存储虚函数的函数指针。类的每个实例对象在头部隐含一个虚表指针（vptr，64位下占 8 字节），指向该类的 vtable。
• 调用寻址过程：基类指针调用 ptr->func() $\to$ 取出对象头部的 vptr $\to$ 在 vtable 中按固定偏移量读取目标函数指针 $\to$ 跳转执行（二次间接寻址）。
• 性能损耗：破坏 CPU 指令缓存与分支预测，默认无法被编译器直接内联（Inlining）。

2. 智能指针（unique_ptr, shared_ptr, weak_ptr）与多线程引用计数#

• unique_ptr：独占所有权，禁止拷贝构造与拷贝赋值，仅支持移动语义（std::move），无额外内存开销（零抽象开销）。
• shared_ptr：共享所有权，内部包含指向目标对象的指针和指向控制块（Control Block）的指针。控制块中维护两个计数器：强引用计数（Strong Ref Count）与弱引用计数（Weak Ref Count）。
  • make_shared 优势：一次性申请内存，将目标对象和控制块连续分配，减少一次内存分配并提高 Cache 命中率。
  • 多线程安全性：引用计数的增减是原子操作（std::atomic），但在多线程下并发读写同一个 shared_ptr 实例本身不是线程安全的（指针切换与计数增减非整体原子）。
• weak_ptr：弱引用，不增加强引用计数，用于解决 shared_ptr 的循环引用（Circular Reference）导致的内存泄漏。访问对象前必须调用 .lock() 提升为 shared_ptr，若对象已析构则返回 nullptr。控制块在强引用归 0 且弱引用归 0 后才会被彻底销毁。

3. 析构函数深度剖析（为什么基类析构必须是 virtual？内存泄漏？继承下的调用顺序？）#

• 为什么基类析构必须是虚函数？
  • 当通过基类指针删除派生类对象（Base* p = new Derived(); delete p;）时，若基类析构函数不是虚函数，编译器执行静态绑定，仅调用基类的析构函数，派生类的析构函数不会被调用。导致派生类特有的成员变量（如堆内存、文件句柄、网络连接）无法释放，引发内存泄漏与未定义行为（Undefined Behavior）。
• 继承体系下的调用顺序：
  • 构造顺序：基类构造函数 $\to$ 成员对象构造函数 $\to$ 派生类构造函数。
  • 析构顺序：与构造顺序严格相反：派生类析构函数 $\to$ 成员对象析构函数 $\to$ 基类析构函数。
• 父类构造函数中调用 virtual 函数的具体行为：
  • 在执行父类构造函数期间，子类的成员尚未初始化，此时对象的动态类型判定为父类，vptr 仍指向父类的 vtable。因此，调用的必定是父类自身的虚函数版本，不会发生多态分发到子类。

4. C++ 内存布局与栈溢出（Stack Overflow）成因#

• 内存五大分区：
  1. 代码区（Text Segment）：存放机器指令，只读。
  2. 常量区 / 只读数据区（ROData）：字符串字面量、const 全局变量。
  3. 全局 / 静态区（BSS & Data）：Data 段存已初始化的全局/静态变量；BSS 段存未初始化的全局/静态变量（启动时自动清零）。
  4. 堆区（Heap）：由程序员手动分配（malloc / new），由低地址向高地址增长，分配有碎片，速度较慢。
  5. 栈区（Stack）：存储局部变量、函数参数、返回地址。由高地址向低地址连续增长，由操作系统自动管理，速度极快（移动栈指针 ESP/RSP）。
• 栈溢出成因：
  • 递归过深且无终止条件（如 DFS 递归陷入死循环）。
  • 在栈上分配了超大局部数组（如 int buf[1024 * 1024 * 10];，默认线程栈通常仅 1MB~8MB）。

5. 指针（Pointer）与引用（Reference）的底层区别#

• 本质：引用在底层由编译器实现为指针常量（Type* const）。
• 语法与行为差异：
  1. 指针是一个实体变量，有自身独立的内存地址；引用只是变量的别名，&ref 获取的是原变量地址。
  2. 引用定义时必须初始化且不可重绑定（不可重新指向其他对象）；指针可以不初始化、可以为 nullptr、可以在运行期随意改变指向。
  3. sizeof(引用) 等于被引用对象的大小；sizeof(指针) 在 64 位平台恒为 8 字节。
  4. 指针有多级指针（int**），引用没有多级引用（右值引用 && 是类型系统语法，非多级）。

6. 源代码到可执行文件的完整流程#

1. 预处理（Preprocessing, gcc -E）：展开宏定义（#define）、处理条件编译指令（#ifdef）、递归包含头文件（#include）、删除注释。生成 .i 文件。
2. 编译（Compilation, gcc -S）：词法分析、语法分析、语义分析、中间代码生成与代码优化，将预处理后的代码转为汇编代码。生成 .s 文件。
3. 汇编（Assembly, gcc -c）：汇编器将汇编指令逐条翻译为机器可执行的二进制指令（重定位目标文件）。生成 .o / .obj 文件。
4. 链接（Linking, gcc -o）：链接器将各个目标文件与库文件（静态库 .a/.lib、动态库 .so/.dll）拼装，解析符号引用、重定位内存地址，最终生成可执行文件。

7. Lambda 表达式底层原理与使用避坑#

• 底层原理：编译器会自动生成一个隐式仿函数类（Functor Class），重载 operator()。
• 捕获列表机制：
  • 值捕获 [x] / [=]：被捕获的变量作为仿函数类的成员变量，在构造仿函数实例时通过拷贝初始化（默认在内部是 const，加 mutable 可修改副本）。
  • 引用捕获 [&x] / [&]：仿函数类内部保存变量的引用或指针。
• 避坑点（致命悬空引用）：
  • 在异步回调、多线程任务或协程中使用引用捕获局部变量。当外部函数执行完毕退栈后，局部变量被销毁，Lambda 内部访问引发悬空引用（Dangling Reference）野指针崩溃。异步场景必须显式采用值捕获。

8. 继承下的内存布局与菱形继承（虚继承、vbptr、虚基类表）#

• 普通单继承：派生类内存布局为：基类成员变量 $\to$ 派生类成员变量。若有虚函数，对象头部共享基类的 vptr。
• 菱形继承问题：类 B、C 继承自 A，类 D 同时多重继承 B 和 C。此时 D 的实例中包含两份 A 的副本，存在数据二义性与内存浪费。
• 虚继承解决方案（virtual public A）：
  • B 和 C 采用虚继承。在 D 对象的内存布局中，公共基类 A 的成员被移至内存尾部（仅保留一份唯一实例）。
  • B 和 C 的子对象内部引入一个虚基类指针（vbptr），指向虚基类表（vbtable）。表中记录了当前位置到公共基类 A 实例的偏移量（Offset）。

9. new / delete 与 malloc / free 的区别、placement new、new int vs new int()#

• 核心区别：
  1. malloc/free 是 C 标准库函数；new/delete 是 C++ 运算符。
  2. new 先调用 operator new 分配原始内存，随后在内存上自动调用类的构造函数；delete 先调用析构函数，再调用 operator delete 释放内存。
  3. new 失败抛出 std::bad_alloc 异常；malloc 失败返回 NULL。
• new int vs new int()：
  • new int：默认初始化（Default Initialization），对于内置类型，分配的内存不进行清零，值为随机残留垃圾值。
  • new int()：值初始化（Value Initialization），内置类型会被零初始化（Zero-initialized），值为 0。
• delete 如何知道释放多少字节？
  • 内存分配器（如 ptmalloc, jemalloc）在分配内存块时，会在返回指针的前方（Header 头部）隐式写入元数据（Cookie），记录该内存块的总大小与对齐标记。delete 读取头部元数据确定释放大小。
• placement new（定位 new）：
  • 语法：new (ptr) Type(args...)。在已经预先分配好的内存地址 ptr 上就地构造对象，不产生任何新的内存申请，是实现内存池、对象池与自定义容器的核心技术。

10. vector vs list vs deque 深度对比#

• vector（动态连续数组）：
  • 连续内存。CPU 访问时利用空间局部性加载到 Cache Line（64 字节），Cache 命中率高，遍历极快；支持 $O(1)$ 随机访问。
  • 扩容时按 1.5x（MSVC）或 2x（GCC）重新申请大块内存并拷贝/移动，发生迭代器失效。
• list（双向链表）：
  • 节点堆上离散分配，附带两个指针开销；遍历引发 Cache Miss，随机访问 $O(N)$；增删节点不引起其他迭代器失效。
• deque（双端队列）：
  • 内存结构：由一段段固定大小的连续内存缓冲区（Chunk/Buffer）和管理这些缓冲区的**中控映射表（Map of Pointers）**组成。
  • 性能特性：
    • 支持 $O(1)$ 头尾高效插入与删除（push_front / push_back），无需整体搬移内存。
    • 支持 $O(1)$ 随机下标访问 deque[i]，但需两次寻址（先查 Map 定位 Buffer，再查 Buffer 内偏移），速度略慢于 vector。
    • 迭代器由 cur, first, last, node 4 个指针维护，开销与复杂度高于普通指针。

11. unordered_map vs map 差异与哈希冲突解决#

• 底层数据结构：
  • map：底层是红黑树（自平衡二叉查找树）。元素严格按 Key 有序排列，单次查找/增删复杂度稳定为 $O(\log N)$。
  • unordered_map：底层是哈希表（Hash Table）。元素无序，平均查找/增删复杂度为 $O(1)$。
• 哈希冲突解决：
  • 拉链法（Chaining，C++ STL 默认采用）：桶数组中每个槽位维护一个单链表，哈希值相同的元素挂在同链表下。当负载因子（Load Factor）超过阈值（通常 1.0）时触发 rehash。
• 最差情况复杂度：当所有 Key 均发生哈希碰撞时，退化为单链表，查找复杂度变为 $O(N)$。

12. 模板（Template）原理：为什么声明和定义不能分开在 .h 和 .cpp？#

• 编译机制：模板是代码生成的蓝图。编译器只有在看到具体的模板调用点时，才会根据实参类型进行模板实例化（Template Instantiation）。
• 分开编写的问题：若在 .cpp 中定义模板实现，其他文件调用时无法实例化机器码，链接阶段找不到具体符号，报 Undefined reference 错误。
• 规范：模板的声明和定义必须全部写在头文件（.h 或 .hpp）中。

13. inline（内联函数）机制与虚函数能否内联#

• inline 核心：建议编译器在函数调用点直接将函数体代码展开，消除函数调用时的压栈、参数传递、寄存器保存与跳转开销。
• 优缺点：提高短小高频函数的执行速度；但过度使用会导致生成的二进制代码体积膨胀（Code Bloat），降低指令缓存（I-Cache）命中率。
• 虚函数能否 inline？
  • 编译期静态确定调用者类型时（如 Base b; b.virtual_func();），编译器知道确切类型，可以内联。
  • 通过基类指针/引用多态调用时（如 Base* p = new Derived(); p->virtual_func();），调用地址在运行期通过 vtable 动态分发，无法内联。

14. static 与 const 的多维用法#

• static：修饰局部变量（生命周期延至程序结束）、修饰全局变量/函数（限制内部链接）、修饰类成员（属于类本身，静态函数无 this 指针）。
• const：
  • const int* p（常量指针）：指向常量的指针，指向内容不可变，p 指向可变。
  • int* const p（指针常量）：指针自身是常量，p 指向不可变，指向内容可变。
  • 常成员函数 void func() const：承诺不修改类的非 mutable 成员。

15. TCP 与 UDP 的本质区别与游戏网络选型#

16. 深入理解 TCP 三次握手与四次挥手#

• 三次握手流程：
  1. 客户端发送 SYN=1, seq=x，进入 SYN_SENT 状态。
  2. 服务端收到后回复 SYN=1, ACK=1, seq=y, ack=x+1，进入 SYN_RCVD 状态。
  3. 客户端收到后回复 ACK=1, seq=x+1, ack=y+1，双方进入 ESTABLISHED 状态。
  • 为什么不是两次？ 防止历史上失效的旧连接请求报文突然又传送到服务端，导致服务端单方面建立空连接浪费资源；同时确保双方的双向初始序列号（ISN）均得到确认。
• 四次挥手与 TIME_WAIT：
  • 主动关闭方在最后发送完 ACK 后必须停留在 TIME_WAIT 状态持续 $2\text{MSL}$（最长报文段寿命）。
  • 目的：1. 确保被动关闭方收到了最后的 ACK，若丢失可重传；2. 保证本次连接产生的所有旧报文从网络中彻底消失。

17. 可靠 UDP（KCP、ENet）原理：为什么能解决 TCP 队头阻塞？#

• TCP 队头阻塞（Head-of-Line Blocking）：TCP 保证严格顺序交付。如果第 1 号包丢失，后续包只能在缓冲区等待重传，导致网络抖动与延迟激增。
• KCP / 可靠 UDP 破局原理：
  1. 选择性重传（SACK）：只重传真正丢失的数据包，不阻塞后续已到达包的处理。
  2. 快速重传：收到 3 次重复 ACK 立即重传丢失包，无需等待超时定时器。
  3. 非退让流控：弱网下不腰斩发送窗口，牺牲少量带宽换取极低延迟。

18. 游戏同步架构：帧同步（Lockstep） vs 状态同步（State Synchronization）#

• 帧同步（Lockstep）：服务端仅转发玩家的操作指令，客户端基于相同的初始状态和**定点数数学库（Fixed-Point Math）**进行确定性逻辑模拟。带宽极小、天然支持大局战斗回放，常用于 RTS/MOBA。
• 状态同步（State Sync）：游戏逻辑完全由服务端权威计算，定期广播实体状态快照。客户端配合**客户端预测（Client Prediction）与实体插值（Interpolation）**平滑显示。绝对防作弊、断线重连容易，常用于 MMORPG/FPS。

19. 进程、线程与协程的本质差异#

• 进程（Process）：操作系统资源分配和调度的基本单位，拥有独立的虚拟地址空间与内存页表。
• 线程（Thread）：CPU 调度的基本单位，同一进程内的线程共享虚拟内存空间（代码段、堆），拥有独立的栈和寄存器上下文。
• 协程（Coroutine）：用户态的轻量级线程，调度由应用程序控制，无需内核切换。内存占用极小（几 KB），通过显式挂起（yield）让出 CPU。

20. I/O 多路复用（select, poll, epoll）深度解析#

• select / poll：
  • 每次调用需要将整个 fd_set 文件描述符集合从用户态拷贝到内核态。
  • 内核通过 $O(N)$ 轮询遍历所有监听的 socket。
  • select 默认有 1024 个连接上限；poll 基于链表无上限，但仍为 $O(N)$ 线性扫描。
• epoll（Linux 高并发核心）：
  • 数据结构：内核中维护一棵红黑树（保存所有监听的 socket）和一个就绪就绪双向链表（rdllist）。
  • 事件驱动：通过 epoll_ctl 注册 socket，网卡收到数据中断时触发回调，仅将发生事件的 socket 加入就绪链表；调用 epoll_wait 时直接返回就绪链表，时间复杂度 $O(1)$。
  • 水平触发（LT） vs 边缘触发（ET）：
    • LT（Level Triggered，默认）：只要缓冲区还有数据未读完，每次 epoll_wait 都会持续通知。
    • ET（Edge Triggered，高速模式）：仅在状态发生跳变（从未就绪到就绪）时通知一次，必须使用非阻塞 I/O 且循环读完（while (read() > 0) 直到 EAGAIN）。

21. 线程同步原语对比：互斥锁（Mutex）、自旋锁（Spinlock）、条件变量与原子操作（Atomic）#

• 互斥锁（Mutex）：获取失败时线程休眠，陷入内核态上下文切换。适合临界区较长场景。
• 自旋锁（Spinlock）：获取失败时在 CPU 上空循环探测（Busy-wait），避免上下文切换。适合临界区极短的多核并发。
• 原子操作（std::atomic / CAS）：基于 CPU 总线级原子指令（如 LOCK CMPXCHG），在硬件层面保证单个变量操作的原子性，是无锁编程的核心。

22. 现代 GPU 渲染管线（Graphics Pipeline）全流程#

1. 应用阶段（CPU）：视锥体剔除、遮挡剔除、合批、向 GPU 提交 Draw Call。
2. 顶点着色器（Vertex Shader）：顶点坐标 MVP 变换至齐次裁剪空间；法线变换；UV 传递。
3. 光栅化阶段（Rasterization）：三角形遍历与属性插值，将几何图元离散化为屏幕像素片元（Fragment）。
4. Early-Z 深度测试：在片元着色前提前比对深度，剔除被遮挡像素。
5. 片元着色器（Fragment Shader）：纹理采样、PBR 光照计算、阴影衰减，输出片元颜色。
6. 逐片元操作（Per-Fragment Operations）：模板测试 $\to$ 深度测试 $\to$ 混合（Alpha Blending） $\to$ 写入 FrameBuffer。

23. 判断点 $P$ 是否在三角形 $\triangle ABC$ 内部的三种经典数学算法#

1. 二维向量叉乘法（Cross Product / 同向法）： $\vec{C}_1 = \vec{AB} \times \vec{AP}, \quad \vec{C}_2 = \vec{BC} \times \vec{BP}, \quad \vec{C}_3 = \vec{CA} \times \vec{CP}$ 若 $\vec{C}_1.z, \vec{C}_2.z, \vec{C}_3.z$ 符号全部相同，则点在三角形内。
2. 重心坐标法（Barycentric Coordinates）： $P = uA + vB + wC$，满足 $u + v + w = 1$。若 $u \ge 0, v \ge 0, w \ge 0$，则点在内部。
3. 面积法（Area Method）： 若 $S_{\triangle PAB} + S_{\triangle PBC} + S_{\triangle PCA} = S_{\triangle ABC}$，则点在内部。

24. 向量点积（Dot Product）与叉积（Cross Product）的几何应用#

• 点积 $\vec{A} \cdot \vec{B} = |\vec{A}||\vec{B}|\cos\theta = x_1 x_2 + y_1 y_2 + z_1 z_2$：
  • 计算两向量夹角 $\theta$。
  • 朝向判定：$\vec{A} \cdot \vec{B} > 0$ 在前方，$< 0$ 在后方。
  • 光照朗伯余弦定律：$I = \max(0, \vec{N} \cdot \vec{L})$。
  • 正向投影长度计算：$\text{proj} = \vec{A} \cdot \hat{B}$。
• 叉积 $\vec{A} \times \vec{B} = \vec{C}$（$\vec{C} \perp \vec{A}, \vec{B}$）：
  • 计算多边形表面垂直法向量。
  • 在 2D/俯视空间判断目标在自身左侧还是右侧（根据 $\vec{C}.z$ 或 $\vec{C}.y$ 正负）。
  • 计算三角形/多边形有向面积。

25. 抗锯齿技术（Anti-Aliasing）全景对比#

• SSAA（超级采样）：超分辨率渲染后下采样，画质最好，开销暴增 4 倍。
• MSAA（多重采样）：仅在几何边缘做子采样，与延迟渲染天然冲突。
• FXAA（快速近似抗锯齿）：屏幕空间图像边缘模糊，开销极低（$1\text{ms}$），但全屏稍有模糊。
• TAA（时间性抗锯齿）：结合历史多帧运动矢量混合，消除高频高光抖动，但高速运动有残影（Ghosting）。

26. Early-Z 早期深度测试原理与失效时机#

• 原理：GPU 硬件在执行片元着色器（FS）之前提前执行深度测试，丢弃被遮挡像素，省去 FS 计算。
• 失效时机：
  1. FS 中使用了 clip() / discard（Alpha Test）。
  2. FS 中手动修改写入了深度值（SV_Depth）。
  3. 开启了 Alpha Blend（通常关闭深度写入）。

27. 广度优先搜索（BFS）核心范式与无权图最短路径#

1
// 广度优先搜索 (BFS) 标准模板 (FIFO 队列 + visited 集合)
2
void BFS(int startNode, const vector<vector<int>>& graph) {
3
    queue<int> q;
4
    vector<bool> visited(graph.size(), false);
5
    q.push(startNode);
6
    visited[startNode] = true;
7

8
    int level = 0;
9
    while (!q.empty()) {
10
        int size = q.size();
11
        for (int i = 0; i < size; ++i) {
12
            int cur = q.front();
13
            q.pop();
14
            // 处理当前节点逻辑
15
            for (int neighbor : graph[cur]) {
16
                if (!visited[neighbor]) {
17
                    visited[neighbor] = true;
18
                    q.push(neighbor);
19
                }
20
            }
21
        }
22
        level++; // 层级计数 (最短步数)
23
    }
24
}

28. 拓扑排序（Topological Sorting）与游戏技能/任务依赖链#

• 算法（Kahn 算法）：
  1. 统计所有节点的入度（In-degree），将所有入度为 0 的节点推入队列。
  2. 队列弹出节点加入拓扑序列，遍历其所有出边邻居，将邻居的入度减 1。
  3. 若邻居入度变为 0，则推入队列。
  4. 遍历结束后，若拓扑序列长度小于总节点数，说明图中存在有向环（循环依赖）。

29. 汉诺塔（Hanoi Tower）递归数学模型#

• 递推公式：$T(n) = 2T(n-1) + 1 \implies T(n) = 2^n - 1$。
• 分治三步法：
  1. 将 $n-1$ 个盘子从 $A$ 借助 $C$ 移动到 $B$。
  2. 将最大的第 $n$ 个盘子从 $A$ 直接移动到 $C$。
  3. 将 $n-1$ 个盘子从 $B$ 借助 $A$ 移动到 $C$。

30. Redis 排序与 Sorted Set（zset）底层跳表（SkipList）原理#

• 底层双重结构：内部同时维护一个哈希表（dict，保存 member 到 score 映射，支持 $O(1)$ 查找）和一个跳表（zskiplist，按 score 排序，支持范围查询和排名）。
• 跳表原理：
  • 在有序链表之上建立多层索引。每向上增加一层，节点数减半（通过抛硬币随机概率 $p=1/4$ 决定节点层高）。
  • 查找时从最高层链表向右推进，遇到大于目标的节点则向下一层继续搜索，时间复杂度稳定为 $O(\log N)$。
  • 在游戏排行榜系统（Rank/Leaderboard）中高频使用。

31. 判断链表是否有环，并找到入环节点（快慢指针与严格数学证明）#

• 证明：设头到环口为 $a$，环口到相遇点为 $b$，环剩余长为 $c$。 由 $S_{\text{fast}} = 2S_{\text{slow}} \implies a + n(b+c) + b = 2(a+b) \implies a = (n-1)L + c$。 两指针分别从 head 与相遇点出发，每次 1 步，必在环口相遇。

32. Top-K 问题：无序数组找前 K 小 / 前 K 大#

• 大/小顶堆法：维护大小为 $K$ 的堆，时间复杂度 $O(N \log K)$，适合海量数据流。
• 快速选择（QuickSelect）：基于快排 Partition，平均时间复杂度 $O(N)$。

33. C# 值类型 vs 引用类型、装箱/拆箱与 GC 优化#

• 装箱（Boxing）：将值类型转为 object 或接口，在托管堆分配内存并复制数据；拆箱（Unboxing）：获取引用对象的内部值指针。
• 优化技巧：高频逻辑杜绝泛型装箱，结构体通过实现接口配合 where T : struct, IHandler 触发直接内联调用。

34. Unity 资源管理：AssetBundle 与 Addressables 深度机制#

• AssetBundle 依赖冗余：两个 AB 包公共引用的资源若未独立命名打包，会被重复拷贝打入两个包体。必须在构建期扫描依赖树将公共资源提取为独立依赖包。
• 引用计数生命周期：Addressables.LoadAssetAsync 返回 AsyncOperationHandle，内部引用计数 $+1$；必须成对调用 Addressables.Release，归零时触发底层 AB 卸载。

35. Unity 四大合批技术条件与 UI 合批打断判定#

• 静态合批（Static Batching）：合并网格，增加内存占用，顶点上限 64,000。
• 动态合批（Dynamic Batching）：CPU 每帧合并，限制小于 300 顶点的同材质模型。
• GPU Instancing：同材质同 Mesh，通过 Constant Buffer 提交变换矩阵。
• SRP Batcher：同 Shader 变体，常量缓冲区常驻，消除 SetPass Call。
• UGUI 合批打断三要素：图集不一致、层级穿插（Z轴交错）、自定义材质/Mask 模板打断。

36. UE 反射系统（UHT、UProperty、UFunction）底层原理#

• 机制：UE 通过预编译工具 **UHT（Unreal Header Tool）**扫描源码中的 UCLASS(), UPROPERTY(), UFUNCTION() 等宏标记，自动生成元数据代码文件。
• 运行时：引擎启动时自动注册构建 UClass, FProperty, UFunction 全局类型系统，支撑序列化、网络属性同步、蓝图可视化调用与垃圾回收。

37. UE Gameplay 框架核心分层#

• UWorld $\to$ AGameModeBase（权威规则） $\to$ AGameStateBase（全房间公共状态） $\to$ APlayerController（输入驱动与网络主控） $\to$ APawn / ACharacter（物理实体与表现）。

🏢 途游游戏（Tuyoo Games 核心面经专场）#

🏢 米哈游（Gameplay / 引擎方向）#

1. 问：2000 个顶点的模型，Vertex Shader 和 Fragment Shader 各执行多少次？
   • 答：Vertex Shader 严格针对每个顶点执行，若无剔除则执行 2000 次；Fragment Shader 执行次数取决于该模型在屏幕上最终光栅化覆盖的有效像素片元数量（受分辨率、距离远近、视口大小、Overdraw 及 Early-Z 剔除影响）。
2. 问：空类的大小是多少？为什么不是 0？如果有虚函数呢？
   • 答：C++ 空类大小为 1 字节，因为 C++ 标准要求每个独立对象在内存中必须有唯一的地址；若有虚函数，对象头部必须包含一个虚表指针 vptr，在 64 位系统下大小为 8 字节。
3. 问：射击游戏中枪械散射（Spread Cone）怎么在数学上实现？
   • 答：在以枪口正前方向 $\vec{D}$ 为中心轴的圆锥体内生成随机偏转向量。在极坐标系下随机生成偏转角 $\theta \in [0, \theta_{\text{max}}]$ 与旋转角 $\phi \in [0, 2\pi)$，转换为局部偏移量 $(\sin\theta\cos\phi, \sin\theta\sin\phi, \cos\theta)$，再通过旋转矩阵/四元数变换到世界空间。

🏢 腾讯（IEG / 光子 / 天美 / 腾娱）#

1. 问：如何设计一个无缝大地图流式加载与室内外平滑过渡系统？
   • 答：采用多级空间划分（Octree / Grid）与基于距离触发的异步流式加载（Async Level Streaming / Additive Scene）。室内外过渡通过门禁触发区域预加载室内细节，利用 Occlusion Portal（遮挡门）动态剔除外部超大世界网格。
2. 问：strcmp 底层是一个个 char 比较，有没有更高性能的优化方式？
   • 答：使用 SIMD（单指令多数据流，如 AVX-512 / SSE 4.2 指令 _mm_cmpeq_epi8），单周期同时对比 16 或 32 个字节；内存对齐时按 uint64_t 一次性对比 8 字节。
3. 问：骨骼蒙皮动画中 CPU Skinning 与 GPU Skinning 的区别？
   • 答：CPU Skinning 在主线程通过遍历顶点计算骨骼矩阵插值变换（更新 VBO），开销大且占用 CPU；GPU Skinning 将骨骼矩阵调色板存入常量缓冲区（UBO/Texture），在 Vertex Shader 中直接完成顶点位置变换，极大解放 CPU。

🏢 网易雷火#

1. 问：new int 和 new int() 的区别？
   • 答：new int 默认初始化，值为内存随机残留值；new int() 值初始化，自动清零为 0。
2. 问：循环小数如何快速寻找循环节？
   • 答：长除法模拟。使用哈希表 unordered_map<int, int> 记录每次出现的余数（Remainder）及其对应的商在小数中的下标位置。当出现曾经记录过的余数时，当前位置与历史记录位置之间的片段即为循环节。

🏢 库洛游戏 & 点点互动#

1. 问：UI 合批被打断的最常见原因有哪些？
   • 答：1. 图集不一致（交叉穿插不同图集的图片）；2. 动态文字（TextMeshPro 与 Image 交叉层级）；3. 挂载了 Mask（Stencil 打断合批）而非 RectMask2D；4. 界面 Z 轴坐标不为 0 引发网格深度重排。

🏢 英雄游戏 & 莉莉丝#

1. 问：带权重随机掉落物品算法怎么做？（如 0.1 白、0.2 蓝、0.15 橙）
   • 答：前缀和数组 + 二分查找。计算所有权重的累加前缀和数组 prefixSum，生成一个 $[0, \text{TotalWeight})$ 的随机数 $r$，使用 std::upper_bound 在 $O(\log N)$ 时间内二分定位命中的物品区间。
2. 问：正态分布如何转换为均匀分布？
   • 答：利用概率积分变换（Probability Integral Transform）。若随机变量 $X \sim \mathcal{N}(\mu, \sigma^2)$，其累积分布函数（CDF）为 $\Phi(x)$，则变量 $Y = \Phi(X)$ 严格服从 $[0, 1]$ 上的标准均匀分布；反向转换可采用 Box-Muller 变换。

🎮 项目一：《WoodMan》（3D 第一人称 AI 追逐，恐怖解谜，巨人 Mini Game 冠军）#

🧩 项目二：《DotTrack》（3D 网格连线益智，Mengya Game Jam 2026）#

🤖 前沿跨界：中科院自动化所大模型强化学习实习与游戏融合#

• PPO / GRPO 策略优化在游戏 NPC 决策中的应用：利用强化学习替代传统硬编码行为树，训练能够自适应环境障碍、预判玩家路线的智能敌人。
• 端侧神经网络推理（Unity Sentis / ONNX）：在客户端本地高效执行轻量级模型，实现高响应度 NPC 拟真对话与动态环境交互。