速览卡片

一、基本数据类型：值与引用的分野

1.1 八类型与口诀

Lua 只有 8 种基本类型，口诀：“nil 布数串，表函用线”——前四个值类型（nil、boolean、number、string），后四个引用类型（table、function、userdata、thread）。

值类型是复印文件，引用类型是递钥匙——你拿到钥匙的复制品，开的还是同一个柜门。

例 1 · 赋值后的互相影响：local b = a 之后改 b.x，a.x 跟着变（同一柜子）；若改成 b = 新表，只是 b 撕掉旧便利贴改贴新柜子，a 纹丝不动。

1.2 三个高频追问

1.3 table 访问规则（地基中的地基）

• 点号是糖：t.x 完全等价于 t["x"]，只对”合法标识符”字符串键有效；
• 数字键用中括号：t[1]；数组下标从 1 开始；
• t[1]（数字键）和 t["1"]（字符串键）是两个不同的键；
• 多层嵌套像写快递地址：playerData.equips.weapon.enhance，访问和赋值寻路规则相同；
• 键可以是任何类型（table、函数都能当 key），nil 除外。

二、元表：应急指令单

2.1 定义与基本操作

元表是一张普通 table，贴在 table/userdata 上，扮演”应急指令单”：正常操作走通时完全不插手，走不通才翻出来看。指令单上每行是一个 __ 开头的元方法（metamethod）。

1
2
3

local t = {}
setmetatable(t, { __index = function(table, key) return "default" end })
getmetatable(t)   -- 查询元表，没有则返回 nil

raw 前缀四兄弟：rawget / rawset / rawequal / rawlen——绕过元表直接操作本表，相当于”跳过应急指令单，直接开柜门”。

2.2 核心双子：__index 与 __newindex

• __index 指向一张表：本表查不到键 → 去那张表接着查（继承的地基）；
• __index 指向一个函数：调 __index(t, key)，返回值即结果（可做默认值、只读保护、日志）；
• __newindex 指向函数：赋值的最后机会，函数里若不 rawset(t, k, v)，这次赋值悄悄落空；
• 经典用法：__newindex 里先校验再 rawset，就是只读/校验层；配合”数据存进内部表”实现真正的私有字段。

2.3 运算符元方法全家

__add __sub __mul __div __mod __pow __unm（算术）、__concat（.. 连接）、__len（# 长度）、__eq __lt __le（比较）、__call（把表当函数调）、__tostring（print 时）、__gc（userdata 回收时）。

三、深拷贝

浅拷贝只拷第一层（b = {} 再 for 循环赋值）——嵌套的 table 仍是同一个柜子。深拷贝三要素：

1. 递归：遇到 table 就继续往下拷；
2. seen 账本法防循环引用：a.self = a 的结构，不记账会无限递归；
3. 移植元表：拷完别忘了 setmetatable(copy, getmetatable(orig))。

1
2
3
4
5
6
7
8
9
10
11

function deepCopy(orig, seen)
    if type(orig) ~= "table" then return orig end
    seen = seen or {}
    if seen[orig] then return seen[orig] end   -- 账本里有：直接引用，打断循环
    local copy = {}
    seen[orig] = copy                           -- 先记账，再递归
    for k, v in pairs(orig) do
        copy[deepCopy(k, seen)] = deepCopy(v, seen)
    end
    return setmetatable(copy, getmetatable(orig))
end

四、继承

Lua 没有 class 关键字，继承 = 元表 __index 串成的委托链。实例是数据表，方法是类表上的函数，调用时沿链向上找。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Base = {}
Base.__index = Base

function Base.new(name)
    local o = setmetatable({}, Base)   -- 实例的"应急指令单"指向类表
    o.name = name
    return o
end
function Base:speak() print("Base: " .. self.name) end

-- 继承：子类表的 __index 指向父类表（类表层面再套一层委托）
Derived = setmetatable({}, { __index = Base })
Derived.__index = Derived

function Derived.new(name, level)
    local o = Base.new(name)           -- 先走父类构造
    o.level = level
    return setmetatable(o, Derived)    -- 元表换成子类表
end
function Derived:speak()               -- 重写
    print("Derived Lv." .. self.level .. ": " .. self.name)
end

五、闭包

闭包 = 函数 + 它捕获的上值（upvalue）打包成的整体——函数出门自带记忆，记忆存在函数体外、调用者的视野外。

例 1 · 计数器：局部变量 n 本该在 counter 返回后销毁，被内层函数捕获后一直活着，且外界无法直接摸到它——这就是”私有变量”。

1
2
3
4
5
6
7
8
9
10
11
12
13

function counter()
    local n = 0
    return function()
        n = n + 1
        return n
    end
end

local c1 = counter()
local c2 = counter()
c1()  --> 1
c1()  --> 2
c2()  --> 1   （两个闭包各记各的账，互不可见）

六、userdata 与 C 交互

userdata 是 C/C++ 对象在 Lua 侧的取件凭据：Lua 侧只能拿着它、传给它，本体是一块 Lua 代管的内存。分两代：

C 侧通过 lua_CFunction 与 Lua 通信：参数和返回值都走 lua_State 栈——读参数用 lua_toXXX(L, 索引)，返回值是压栈后 return 个数。

七、ToLua：C# ↔ Lua 的”三跳”

C# 对象要进 Lua，由 ObjectTranslator 登记造册：对象 ↔ userdata 一一映射。Lua 调 C# 方法走“三跳”：

• 第一跳：Lua 侧 obj:Method()，obj 是 userdata 查无此键 → 触发元表 __index；
• 第二跳：__index 转发到 C 侧的 lua_CFunction 包装，按名字在注册表里找到对应的 C# 方法信息；
• 第三跳：ObjectTranslator 把 userdata 翻译回 C# 对象，执行真实方法（Wrap 预生成代码直接调用，没生成走反射兜底）。

八、热更新：方案与本质

热更的本质：Lua 脚本是”可下载的资源”而不是”焊死的程序”——换文本即换逻辑。游戏出 bug 不用发版，下发新脚本就完事。

面试速记

1. 口诀”nil 布数串，表函用线”——8 类型，前四值后四引用。
2. 值类型复印文件，引用类型递钥匙；Lua 的 string 像 C# 的 string，不像 C++ 的 std::string。
3. t[1] ≠ t["1"]；数组从 1 开始；带洞的表 #t 不可靠，遍历用 pairs 保全部、ipairs 保连续。
4. __index 读兜底、__newindex 写拦截（不 rawset 就落空）；raw 系列 = 跳过应急指令单。
5. 继承 = 委托链：实例 → 类表（__index）→ 父类表（元表的 __index）；调父类版本写 Base.speak(self)。
6. 闭包 = 函数 + 上值；LuaJIT（5.1）循环闭包共享 upvalue，捕获前手动 local 复制。
7. userdata = C 对象的取件凭据；full 有 __gc 与 GC 联动，light 只是裸指针名片；查无键直接报错。
8. ToLua 三跳：__index 转发 → C 包装查册 → ObjectTranslator 翻译执行；ID 轻但没有 GC 联动。
9. 热更本质 = 脚本是资源不是程序；iOS 禁 JIT 所以 C# 只能 AOT，huatuo 用解释执行破局。
10. 热更的边界：C# 框架层 bug 热不了，Lua↔C# 高频互调有三跳成本。

C# 八股复习笔记

一、速览卡片

二、逐考点详解

① 引用类型 vs 值类型

值类型：struct、int、float、bool、enum。变量本身就是数据，赋值 = 整体复印，之后两个变量互不干扰。局部变量通常在栈上；但作为类的字段时跟着对象住在堆上。

引用类型：class、string、array、delegate。变量里装的是指向堆上对象的引用（可重新指向别的对象，类似 C++ 指针而非 C++ 引用）。赋值 = 拷贝引用，两个变量指向同一个对象。

类比：值类型 = 复制粘贴一个文件副本；引用类型 = 创建一个指向同一文件的快捷方式。 给快捷方式换个指向目标（p2 = new Player()），不影响别的快捷方式；但顺着快捷方式改文件内容，大家看到的都是同一个文件。

② 装箱与拆箱

• 装箱：在堆上 new 一个 object，把值拷贝进去，返回引用。每次装箱都制造一个短命堆对象。
• 拆箱：类型检查（不符抛 InvalidCastException）+ 把值从堆对象拷回栈变量。不申请内存、不释放任何东西，堆上原对象纹丝不动。

例 1 · 造无限序列：while (true) { yield return i++; } —— 调用方要几个给几个，永不主动算完。
例 2 · 省内存遍历：大文件逐行 yield return line，不用一次加载全部。
例 3 · 高频坑：ArrayList.Add(5) —— 每次 Add 都装箱；List<int>.Add(5) —— 泛型，零装箱。

③ GC 机制

垃圾的定义：从所有”根”出发沿引用链走不到的 = 垃圾。C# 没有 C++ 那种确定性生命周期——生死由”是否可达”决定，回收时机不确定。

标记 → 清除 → 压缩 三步：

1. 标记：从四类根出发染色，没染到的 = 垃圾。
2. 清除：回收垃圾内存。
3. 压缩：存活对象往一端挪动挤紧，消除碎片，并更新所有指向它们的引用。

分代：大部分对象死得很快，所以——

LOH（大对象堆）：≥ 85KB 的对象单独放，不压缩（搬一次太贵），易碎片化。

④ List & Array

List<T> 底层 = T[] 数组 + Count（元素个数）+ Capacity（容量）。

扩容流程：Add 时发现 Count == Capacity → 申请新数组（容量约翻倍）→ 元素逐个拷过去 → 内部指针改指新数组 → 旧数组变 GC 垃圾。

• 几何翻倍使连续 Add 的总拷贝代价为 O(n)；”加 1 扩 1”会退化成 O(n²)。
• 扩容瞬间有性能毛刺（分配 + 全量拷贝）；能预估就用 new List<T>(capacity) 避开。
• 没有原地扩容：托管堆对象大小创建时定死，realloc 式”续租”在 GC 堆上不存在——永远是”退旧房、买新房、搬家”。

例 1 · 预估容量：战斗开始前 new List<Enemy>(预估波次数量)。
例 2 · 复用容器：每帧 LINQ/临时 List 用对象池复用，避开 GC。

⑤ Dictionary

目标：按键快速找值。键 → 哈希 → 数字 → 下标：

两个数组，永远等长，扩容一起扩：

插入示例（容量 5，”Apple” hashCode=12 → 12%5=2）：

1
2
3
4
5

buckets: [ -1, -1,  0, -1, -1 ]     entries[0] = { "Apple", ..., next=-1 }
插入 "Banana"（7%5=2，冲突）：
  新条目进 entries 空位（1 号），串到链头，2 号桶改指新条目
buckets: [ -1, -1,  1, -1, -1 ]
entries[1] = { "Banana", ..., next=0 }   ← 链：1号 → 0号

扩容：装载因子过高 → 两数组约翻倍 → 全量 rehash（有毛刺，换来链条重新变短）。删除的条目不缩数组，进 freeList 等待复用。

类比：buckets 是带索引卡的抽屉，entries 是仓库货架。货架扩到 200 格，抽屉必须跟着做 200 格——因为落位公式是”编号 % 200”。

⑥ 委托 & 事件

委托：类型安全的函数指针 + 多播清单。

1
2
3
4
5
6
7
8
9
10
11
12

delegate void OnHitHandler(int damage);   // 声明一种"函数类型"（合同）

void ShowDamageNumber(int damage) { /* UI 飘字 */ }
void PlayHitSound(int damage)     { /* 音效 */ }
void ShakeCamera(int damage)      { /* 震屏 */ }

OnHitHandler h;
h = ShowDamageNumber;   // 语法糖：new OnHitHandler(ShowDamageNumber)，把方法装进清单
h += PlayHitSound;      // 追加：Delegate.Combine
h += ShakeCamera;

h(50);   // 一次调用，三个函数依次执行；50 原样传给每一个

事件：给委托上锁。

1
2
3
4
5
6
7

public event OnHitHandler OnHit;   // 发布者类内声明

// 外部代码只能：
OnHit += ShowDamageNumber;    // ✅ 订阅
OnHit -= ShowDamageNumber;    // ✅ 退订
// OnHit = null;   // ❌ 编译错误：不许清空
// OnHit(50);      // ❌ 编译错误：只能在声明事件的类内部触发

⑦ 协程

本质：IEnumerator 状态机 + Unity 主线程调度。不是多线程——和 Update 共享同一条时间线，是单线程上的协作式并发。

状态机三要素：MoveNext()（从上次暂停处执行到下一个 yield，返回 false = 走完）、Current（本次 yield return 交出的值）、state（内部状态编号）。

等待期间零执行：MoveNext 不被调用，那段代码冻结、不占 CPU（不是空转）。代价：协程里写死循环照样卡死主线程。

1
2
3
4
5
6
7

IEnumerator AttackRoutine() {
    Debug.Log("举刀");
    yield return null;                        // 暂停到下帧
    yield return new WaitForSeconds(2f);      // 暂停 2 秒
    yield return new WaitUntil(() => hp < 30); // 每帧检查条件，满足才继续
    Debug.Log("收招");
}

三、易混淆点对比汇总

四、流程图

图 1 · GC 标记-清除-压缩

蓝 = 固定环节，绿 = 主流程，黄 = 开销大头，红 = 延迟回收分支

图 2 · Dictionary 查找

图 3 · 协程每帧调度循环

全程主线程；条件不满足期间 MoveNext 根本不被调用（零 CPU，不是空转）

五、面试速记

1. 值类型 = 复制文件，引用类型 = 创建快捷方式；快捷方式换目标不影响别人，顺着改文件内容大家都看见。
2. 装箱 = 值类型套壳上堆（GC 压力来源），拆箱 = 验壳取值（无分配）。
3. GC 的根不是运行时统计的，是 JIT 编译时写好的四张表：栈映射、静态字段、GCHandle、终结队列。
4. 频繁短命对象不可怕（死在 Gen0），可怕的是老对象引用复杂 + 大对象（LOH 不压缩）。
5. 压缩两笔账：memcpy 搬运 + 按引用总数更新地址；固定对象 → 障碍物 → 碎片。
6. List = T[] + Count + Capacity；无原地扩容，永远是”退旧房买新房”。
7. Dictionary：buckets 是门牌、entries 是仓库，等长、共扩容；hashCode 不变，rehash 变的是模数。
8. 委托 = 类型安全函数指针 + 多播；event = 上锁的清单（只许订阅不许篡改）。
9. 协程调用零执行，首次 MoveNext 才开工；StartCoroutine = 造机器 + 首次推进 + 登记。
10. yield return 后面放啥，取决于谁在读 Current——foreach 读数据，Unity 调度器读”何时恢复”的指令。
11. lambda 捕获值类型 = 变量搬进堆上的闭包对象（储物柜），int 不变引用，共享的是同一个格子。
12. 协程与主线程共享变量不用加锁——交错只发生在 yield 边界；并发 ≠ 并行 ≠ 多线程。

整理方式：以”提问 → 纠错 → 追问”的复习对话为底稿，按笔记编号归档；每个 Q/A 框对应一次真实的理解拐点。

C++ 八股复习笔记

主线记忆：“指针赋值拷的是地址，值拷贝造的是新对象；move 只贴标签，搬家靠构造。”

一、速览卡片

二、逐考点详解

① 虚函数表与 vptr

动态多态的三要素：继承 + 虚函数重写 + 通过基类指针或引用调用。三者缺一，多态不成立。

• 虚表（vtbl）：编译期由编译器为每个含虚函数的类生成，存在只读数据段（.rodata），全类只有一份，与创建几个对象无关。
• vptr：存放在对象内存布局的最前面（64 位下占前 8 字节，在成员变量之前），每次构造对象时由构造函数里编译器插入的代码写入——不是链接期初始化，链接器根本接触不到运行时创建的对象。多继承时对象里有多个基类子对象，每个都可能有各自的 vptr，各指向各的虚表。
• 虚函数代码：和普通成员函数一样在代码段（.text），对象里只存指向虚表的指针。

构造/析构期间的 vptr 切换（面试加分项）：构造 Derived 时先执行 Base()，此刻 vptr 指向 Base 的虚表；Base 构造完、进入 Derived() 时改写为 Derived 的虚表。析构正好镜像：Derived 析构函数体执行完后切回 Base 虚表，再执行 ~Base。

推论：构造/析构函数中调用虚函数不发生多态——此刻 vptr 还指着本类的表，调用的是本类版本。

② 左值、右值与移动语义

定义：左值 = 有身份（identity）的表达式——有名字、可取地址、可持续存在；右值 = 临时的、将亡的表达式——字面量、临时对象、std::move(a)、返回值。

输出题（构造列表 + 左值陷阱）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class A {
public:
    A()            { std::cout << "a"; }
    A(const A&)    { std::cout << "b"; }
    A(A&&)         { std::cout << "c"; }
};

class B : public A {
public:
    B()          : A()   { std::cout << "1"; }
    B(const B& o): A(o)  { std::cout << "2"; }
    B(B&& o)     : A(o)  { std::cout << "3"; }   // 注意：A(o) 传的是左值
};

B b1;                 // 输出 a1（先父后子）
B b2 = b1;            // 输出 b2（拷贝构造）
B b3(std::move(b1));  // 输出 b3 ← 陷阱！

③ new/delete、malloc/free 与野指针

核心对比：

必须同族配对：new↔delete、new[]↔delete[]、malloc↔free。混用是未定义行为。

malloc 三部曲：

1. 查空闲账本：free 时小块不还 OS，登记进空闲链表（分箱 bins）；申请时按大小查账本，有则拆分返回，顺带合并相邻碎片——全程无系统调用。
2. 账本没有 → 向 OS 进货：小块走 brk 把堆顶推高，大块（默认 128KB 以上）走 mmap 在映射区开一块，切出所需返回。
3. OS 也不给 → 才返回 NULL。

进程内存布局（低 → 高）：

1
2
3
4
5
6
7
8
9
10
11

低地址
┌ .text   代码段（机器指令，虚函数代码在这）
├ .rodata 只读数据（常量字符串、虚函数表）
├ .data   已初始化全局/静态变量
├ .bss    未初始化全局/静态变量
├ 堆 ↑   向高地址增长（new/malloc，小块走 brk）
│        （大片空隙）
├ mmap 区 动态库 .so、malloc 大块（≥128KB）
├ 栈 ↓   向低地址增长（局部变量、函数参数）
└ 内核空间（用户程序不可直接访问）
高地址

栈向下、堆向上，相向而长，为彼此腾出空间。栈空间有限（默认约 8MB），但栈帧分配只是挪动栈指针，无系统调用，极快。

④ 智能指针

shared_ptr 结构：对象指针 + 控制块指针（引用计数、弱引用计数、删除器）。多线程同时拷贝/销毁各自的 shared_ptr 是安全的——计数器是原子类型，加 1 减 1 不可分割。

循环引用与 weak_ptr：A、B 互持 shared_ptr 时，双方强计数互相顶住（外部释放后各自剩 1），谁都到不了 0，双双泄漏。weak_ptr 只加弱计数、不动强计数，A 的生死不再依赖 B，死结解开。

规则：强计数归零 → 对象立即析构（与弱计数无关）；弱计数归零 → 控制块才释放（weak_ptr 还要靠它查询状态）。

1
2
3
4
5
6
7

std::weak_ptr<A> pa;
std::shared_ptr<A> tmp = pa.lock();   // 升级：强计数 +1，使用期间对象不死
if (tmp) {
    tmp->foo();                       // A 还活着
} else {
    // A 已死，lock 返回空 shared_ptr，走兜底逻辑
}

weak_ptr 不能直接解引用，必须先 lock() 升级成 shared_ptr 再用——升级同时给对象上了”使用期间不死”的保险。

⑤ struct 与 class

C++ 中两者本质是同一个东西，只有两点语法差别：

习惯上 struct 表达纯数据聚合（POD），class 表达有行为、有封装的对象——这是风格约定，不是能力差异。多态、虚函数、模板，两者完全等价。

⑥ delete this

合法，本质是 delete 一个普通指针——对象自己销毁自己，常用于引用计数归零、连接关闭等”无人认领”的时刻。

三条铁律：

1. 只能用于 new/malloc 出来的堆对象；栈对象 delete this 是未定义行为。常配合私有化构造函数 + 静态工厂方法（create）强制堆分配。
2. delete this 之后，严禁再访问任何成员、调用任何成员函数——this 已成悬垂指针，函数里剩下的唯一合法语句是 return。
3. 调用方此后不得再使用该指针。

类比：安乐死——合法执行，但执行后不存在”再去做什么事”，只能结束。

⑦ 内存对齐与缓存行

对齐的本质：CPU 通过内存总线按块取数（64 位机器一块 8 字节），且 L1/L2/L3 缓存与内存之间以缓存行（64 字节）为最小单位搬运——读 1 字节，整条 64 字节一起进缓存。

• 数据地址是其类型大小的整数倍 → 恰好落在同一块里，一次取全；
• 错位（跨两块）→ 两次传输再拼接，慢一倍；老架构直接硬件异常。

malloc 一律返回 16 字节对齐的地址：它不知道调用方会存什么类型，按最严标准保证安全。结构体中每个成员按自身对齐要求摆放，不足填充（padding），所以 sizeof 可能大于成员之和——大成员放前面可少浪费尾部填充。

64 字节对齐与伪共享：两个线程分别写的变量若挤在同一条缓存行里，缓存一致性会让整条行互相失效——两核抢一行，性能暴跌。这就是伪共享。解法是让热点数据独占一行：

1

struct alignas(64) Data { int a; };   // 一人一行，互不干扰

例 1 · 防伪共享：两个线程高频写的计数器，各自 alignas(64) 分开放置。
例 2 · 配合 SIMD：向量计算要求 16/32/64 字节对齐的加载指令。

⑧ 进程、线程与同步

进程 vs 线程：进程是资源分配的最小单位，线程是 CPU 调度的最小单位。线程共享进程地址空间（堆、全局变量、文件句柄），独享栈和寄存器上下文；线程切换不换页表、不刷 TLB，成本低得多。

同步手段全家桶：

lock-free 的概念澄清：它不是”代码里没有锁”，而是一条性质——任何线程停摆，系统整体仍有线程在推进。基于锁的代码里，持锁线程被挂起会拖死所有等待者；CAS 循环没有”谁锁谁”的关系，被挂起的线程只是自己慢点，别人照样成功。更强的 wait-free 保证每个线程有限步内完成（lock-free 只保证”有人能走”，wait-free 保证”人人都能走”）。is_lock_free() 问的是”原子操作在硬件上是否真无锁”，与算法层面是两个问题。代价：CAS 反复失败烧 CPU、ABA 问题、内存序复杂——工程默认用锁，只在剖析证明的热点处上无锁。

线程安全单例（标准答案）：

1
2
3
4
5
6
7
8
9
10
11

class Singleton {
public:
    static Singleton& get() {
        static Singleton instance;   // Magic Statics：标准保证初始化线程安全
        return instance;
    }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
private:
    Singleton() {}
};

C++11 起标准保证：函数内 static 局部变量只初始化一次，多线程同时首次调用时只有一个线程执行初始化，其余自动等待，之后零开销——懒加载、线程安全、无 DCL 指令重排坑，一个写法全部解决。老式懒汉双检锁（DCL）需要处理”分配内存 → 构造 → 写指针”被重排成半成品的问题，要靠内存屏障，易写错，已无必要。饿汉式在程序启动（单线程阶段）即创建，天然无线程安全问题，但启动就付账，可能没人用。

⑨ 编译的四个阶段

记忆：预处理摊大饼 → 编译变汇编 → 汇编变机器码 → 链接拼全家。类比流水线：备料（拆包缩写）→ 翻译操作手册 → 转成机器人指令（电话号码还空着）→ 汇总装订总手册并查号填电话。

⑩ 静态链接与动态链接

类比：静态是出书和引用文字直接抄进自己书里（单看就够，但永远用旧版）；动态是写”详见《XX 手册》第 3 页”（书薄了、手册出新版自动用新版，但读者手里必须有那本手册）。

⑪ static 的四种用法

文件级 static 是”本文件的私人物品”；类级 static 是”类本身的财产”。

⑫ inline、深拷贝与移动赋值

深拷贝与 Rule of Three/Five：类里有裸指针时，编译器默认生成的拷贝构造是浅拷贝——两个对象的指针指向同一块内存，析构时重复释放，崩溃。深拷贝就是自己写拷贝构造：申请新内存 + 拷内容。

三、易混淆点对比汇总

四、流程图

图 1 · malloc 分配决策流

蓝 = 固定环节，绿 = 运行时分支，黄 = 可配置阈值

图 2 · 编译流水线

图 3 · 构造/析构期间 vptr 切换

推论：构造/析构中调虚函数 → 永远调到本类版本（无多态）

五、面试速记

1. 指针赋值拷的是地址，值拷贝造的是新对象；新对象的 vptr 由构造它的构造函数决定，与数据从哪拷来无关。
2. move 只贴标签，搬家靠构造；有名字的右值引用是左值，每层传递资源要自己重新 move。
3. 普通成员函数是编译器指路，虚函数是对象自己找路——nullptr 没有路标。
4. 有虚函数的类，析构必 virtual。
5. new/delete、new[]/delete[]、malloc/free 必须同族配对；混用是未定义行为。
6. 野指针是”指针在、内存没了”，泄漏是”内存在、指针没了”。
7. shared_ptr 保证计数正确，不保证对象读写安全。
8. malloc 三部曲：查账本 → 向 OS 进货 → 才允许失败。
9. 需要析构函数 = 需要手写全部拷贝家族（Rule of Three/Five），或者用智能指针让法则自动满足。
10. C++11 之后，线程安全单例 = 一个函数内 static 变量。
11. inline 的本义是建议展开，主业是解决头文件多重定义。
12. 临界区短到比”睡觉+唤醒”还便宜才用自旋锁，否则用 mutex。

整理方式：以”提问 → 纠错 → 追问”的复习对话为底稿，按考点编号归档；所有代码均经对话验证。

速览卡片

2.1 综述

洋娃娃工厂例子：流水线各工序并行，产量取决于最慢的工序（bottleneck）。

渲染流程分三个概念阶段：应用阶段、几何阶段、光栅化阶段。划分依据是谁拥有控制权——应用阶段 CPU 控制，后两个阶段 GPU 接管；各阶段之间流水线并行，”应用阶段”在整个帧的时间内持续发生。

2.2 CPU 和 GPU 之间的通信

应用阶段三个任务：准备场景数据（摄像机、视锥体、模型、光源）；粗粒度剔除（culling）；设置渲染状态。输出是渲染图元。

数据流向：硬盘 → 内存（全部渲染数据）→ 显存（GPU 要用的子集）。显卡对显存访问更快、且大多数显卡不能直接访问 RAM；数据进显存后 RAM 副本通常可删，但 CPU 还要做碰撞检测/动画的数据要保留。

渲染状态定义网格怎么被渲染：用哪个顶点着色器/片元着色器、光源属性、材质等。不改状态，所有网格用同一种状态渲染。

Draw Call 就是一个命令，发起方是 CPU，接收方是 GPU，只指向图元列表，材质信息上一步已设好。

2.3 GPU 流水线

先给出书中图 2.6 的完整流程，后文小节按此流程逐站展开：

2.3.2 顶点着色器

顶点着色器（Vertex Shader）：每顶点调用一次；不能创建/销毁顶点，无法得知顶点间关系，因此可高速并行。两个主要工作：坐标变换和逐顶点光照。

1

o.pos = mul(UNITY_MVP, v.position);  // 模型空间 → 齐次裁剪空间

MVP = 模型变换（模型空间→世界空间，即 Transform 组件）、V 观察变换（世界→相机空间，相机变换的逆）、P 投影变换（相机→齐次裁剪空间）。输出仍是四维、w≠1，”压扁”发生在后面的透视除法。

2.3.3 裁剪

裁剪（Clipping）处理三种关系：完全在内直接传递、完全在外剔除、部分在内则在边界处生成新顶点（位于图元与视野边界的交点）。不可编程，可配置（自定义裁剪平面）。

2.3.4 屏幕映射

屏幕映射（Screen Mapping）：x、y 从 [-1,1] 缩放到窗口分辨率（如 1080×1920）。z 不处理，与屏幕坐标组成窗口坐标系传给光栅化。

坑：OpenGL 以左下角为 (0,0)，DirectX 以左上角为 (0,0)——图像倒转常因于此。

2.3.5 & 2.3.6 三角形设置与遍历

进入光栅化概念阶段。三角形设置（Triangle Setup）计算光栅化所需信息（边界表示方式）；三角形遍历（Triangle Traversal）判断覆盖哪些像素，并对覆盖区域插值顶点信息（图 2.12 的深度插值例子）。都是固定函数。

2.3.7 片元着色器

片元着色器（Fragment Shader）实现逐片元（Per-Fragment）着色，完全可编程。最重要技术：纹理采样（UV 是插值来的）。DirectX 里叫像素着色器，但”片元”更准确（此时还不是像素）。

2.3.8 逐片元操作

逐片元操作（Per-Fragment Operations）：如修改颜色、深度缓冲、进行混合等，不可编程但可配置性很高。流程：片元 → 模板测试 → 深度测试 → 混合 → 颜色缓冲区。

两个补充：

• Early-Z 技术：测试逻辑上在片元着色器之后，但 GPU 会尽量提前（避免算完颜色才发现被舍弃）。与透明度测试（clip）冲突——着色器可能推翻提前测试的结果，GPU 检测到冲突就禁用提前测试，这就是透明度测试性能下降的原因。
• 双重缓冲（Double Buffering）：渲染在后置缓冲（Back Buffer），完成后与前置缓冲（Front Buffer）交换，画面连续。

2.4 容易困惑的地方

2.4.1 OpenGL/DirectX 与显卡驱动

OpenGL/DirectX 是图像应用编程接口，架起应用与 GPU 的桥梁：应用发命令 → 接口转给显卡驱动 → 驱动翻译成 GPU 语言 + 把纹理转成 GPU 支持的格式（驱动像”显卡的操作系统”）。

2.4.2 HLSL、GLSL、CG

HLSL（DirectX）、GLSL（OpenGL）、CG（NVIDIA），先编译成与机器无关的中间语言（IL），再由驱动翻译。GLSL 跨平台但编译依赖硬件厂商（结果可能不一致）；HLSL 微软统一编译但几乎仅限微软平台；CG 语法近 HLSL、可无缝移植，但可能用不上 OpenGL 新特性。

2.4.3 Draw Call

误区：以为元凶是 GPU 状态切换。其实”拖后腿”的是 CPU。

2.4.4 固定管线渲染

早期 GPU 只能配置不能编程；如今固定管线已退出历史舞台（OpenGL 3.2 Core Profile 完全移除），维护老项目才需要学。

2.5 什么是 Shader

一句话：Shader 就是 GPU 流水线上一些可高度编程的阶段（顶点/片元着色器必写，细分/几何着色器可选）。出色画面需所有阶段配合：渲染状态、混合函数、深度测试/写入的开关。

易混淆点对比汇总

📇 速览卡片（3 分钟复习）

📝 详细笔记

1. Host 与 ENetMultiplayerPeer

Godot 4 的 P2P 联机基于 ENet 库，底层走 UDP 协议。开发者不需要手动处理 Socket、NAT Punch-through 或数据包序列化，直接通过 ENetMultiplayerPeer 一个高层实例完成端对端管理。

1
2
3
4
5
6
7

var peer = ENetMultiplayerPeer.new()
# 创建主机（监听）
peer.create_server(port, max_clients)
# 或加入房间（客户端）
peer.create_client(address, port)

multiplayer.multiplayer_peer = peer

ENetMultiplayerPeer.new() 即为一个完整的端对端实例，封装了连接管理、心跳、丢包重传等细节。

2. @rpc 注解四参数

Godot 4 使用 @rpc(...) 标记远程调用函数，四个位置参数决定了网络行为的全部策略：

1
2
3

@rpc(A, B, C, D)
func my_remote_func():
    pass

A —— 执行范围（本地 vs 远端）

B —— 调用权限（谁能发起）

C —— 传输可靠性

D —— 通道编号 (Channel)

• 取值范围：0 ~ 9，共 10 条独立通道
• 作用类似端口分流：不同通道的数据互不阻塞，可分别设置带宽上限
• 典型用法：
  • 通道 0：reliable 状态同步（低带宽、高优先级）
  • 通道 1：unreliable 位置同步（高频、可丢包）
  • 通道 2：聊天/语音（独立带宽限制）

💻 代码示例

主机创建与 RPC 调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

extends Node

@rpc("call_remote", "authority", "reliable", 0)
func start_game():
    # 只有房主能调用，通知所有客户端游戏开始
    get_tree().change_scene_to_file("res://Game.tscn")

@rpc("call_local", "any_peer", "unreliable", 1)
func update_position(pos: Vector2):
    # 任意玩家都能发，本地也立即执行，高频位置同步
    $Character.position = pos

func _ready():
    var peer = ENetMultiplayerPeer.new()
    peer.create_server(9999, 4)
    multiplayer.multiplayer_peer = peer
    multiplayer.peer_connected.connect(_on_peer_connected)

func _on_peer_connected(id: int):
    print("玩家 ", id, " 已连接")
    # 房主调用，所有客户端（包括本地）执行 start_game
    start_game.rpc()

客户端加入

1
2
3
4
5
6
7
8

func join_game(ip: String, port: int):
    var peer = ENetMultiplayerPeer.new()
    peer.create_client(ip, port)
    multiplayer.multiplayer_peer = peer
    multiplayer.connected_to_server.connect(_on_connected)

func _on_connected():
    print("已连接到服务器，本机 ID: ", multiplayer.get_unique_id())

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1

$ hexo new "My New Post"

More info: Writing

Run server

1

$ hexo server

More info: Server

Generate static files

1

$ hexo generate

More info: Generating

Deploy to remote sites

1

$ hexo deploy

More info: Deployment