闭包详解

QSTX2026/8/2大约 10 分钟

闭包详解 - 从概念到四种语言的实现

闭包（Closure）是一个函数与其捕获的外部变量的组合体。一句话定义：

闭包 = 函数 + 其引用的外部变量（自由变量）的绑定。

无论什么语言，闭包本质上做了同一件事：让一个函数"记住"它诞生时所在的作用域里的变量，即使那个作用域已经执行完毕。

一、核心概念

1.1 自由变量 vs 绑定变量

def outer():
    x = 10           # x 对外部函数是局部变量，对 inner 是自由变量（未在 inner 内定义）
    y = 20           # y 同理

    def inner():
        print(x)     # 引用外部变量 x → x 被 inner "捕获"
        # y 未被引用 → 不会被闭包捕获

绑定变量：在函数自身作用域内定义的变量（参数 + 局部变量）
自由变量（Free Variable）：函数引用了但不在自身作用域内定义的变量

闭包的核心就是当一个函数引用自由变量时，这些自由变量与该函数绑定在一起形成的实体。

1.2 闭包的生命周期

关键：闭包会延长被捕获变量的生命周期。这些变量不会在外部函数返回时销毁，而是存活到闭包本身被回收为止。

二、C++：Lambda 与捕获列表

C++ 的闭包通过 Lambda 表达式实现。C++ 的独特之处在于显式捕获列表——程序员明确指定哪些变量以何种方式被捕获。

2.1 捕获方式

int a = 10;
int b = 20;

// [=] 值捕获：拷贝所有外部变量
auto f1 = [=]() { return a + b; };   // a, b 被拷贝进闭包

// [&] 引用捕获：引用所有外部变量
auto f2 = [&]() { a = 100; };        // 可以修改外部变量

// 显式捕获
auto f3 = [a, &b]() { return a + b; };  // a 值捕获，b 引用捕获

// mutable：允许修改值捕获的副本（不影响原变量）
auto f4 = [a]() mutable { a++; return a; };

2.2 捕获列表与性能取舍

std::vector<int> data = {1, 2, 3, 4, 5};
int threshold = 3;

// 引用捕获：不拷贝，但需保证闭包使用时变量还活着
auto ref = [&threshold](int x) { return x > threshold; };

// 值捕获：拷贝，安全但有开销（大对象不宜拷贝）
auto val = [threshold](int x) { return x > threshold; };

// 游戏引擎中的典型用法：STL 算法 + lambda
auto it = std::find_if(data.begin(), data.end(),
    [threshold](int x) { return x > threshold; });

2.3 `std::function` 与闭包存储

#include <functional>

// std::function 可以持有任意可调用对象，包括 lambda
std::function<int(int, int)> createAdder()
{
    int base = 100;
    return [base](int a, int b) { return base + a + b; };
    // base 被值捕获，即使 lambda 离开作用域，base 的副本仍在
}

auto adder = createAdder();
adder(1, 2);  // → 103

2.4 C++ 闭包的底层

C++ lambda 本质上是一个匿名函数对象（仿函数）：

// 这个 lambda：
auto fn = [x](int y) { return x + y; };

// 编译器大致生成等价于：
struct __anonymous {
    int x;                              // 捕获的变量变成成员
    auto operator()(int y) const { return x + y; }
};
__anonymous fn{x};                      // 拷贝捕获的变量，构造对象

因此 C++ lambda 的调用开销为零（可以被内联），捕获的变量在线程/作用域安全方面需要程序员显式控制。引用捕获需确保生命周期，值捕获注意拷贝开销。

三、C#：委托与捕获变量

C# 的 Lambda 是.NET 中的一等公民，通过委托（Delegate）和编译器生成的闭包类实现。Unity 开发中经常与 Action、Func、事件回调一起出现。

3.1 基础语法

// 函数内部定义闭包
int multiplier = 3;

Func<int, int> multiply = x => x * multiplier;
// multiplier 被捕获 —— C# 编译器自动分析引用，无需程序员声明

multiply(5);  // → 15

3.2 捕获位置与生命周期

public Func<int> CreateCounter()
{
    int count = 0;              // 局部变量
    return () => ++count;       // 闭包捕获 count
}
// CreateCounter 返回后，count 没有消亡，被闭包持有

var counter = CreateCounter();
counter();  // → 1
counter();  // → 2

3.3 闭包的陷阱：循环变量捕获

// ❌ 问题写法
var actions = new List<Action>();
for (int i = 0; i < 3; i++)
    actions.Add(() => Console.WriteLine(i));

foreach (var a in actions)
    a();  // 输出：3 3 3（不是 0 1 2！）

// 原因：lambda 捕获了同一个变量 i，循环结束后 i = 3

// ✅ 正确写法（C# 5+ foreach 自动生成新变量）
foreach (int i in new[] { 0, 1, 2 })
    actions.Add(() => Console.WriteLine(i));
// 输出：0 1 2

3.4 Unity 中的闭包

// 事件注册时注意避免闭包带来的意外捕获
int id = 5;
button.onClick.AddListener(() => Debug.Log($"Clicked button {id}"));
// id 被闭包持有，即使方法执行完，只要监听器存在就还在

闭包会延长变量生命周期，在 Unity 中如果注册了持久事件但闭包持有重量级引用（如 Texture2D），可能导致内存泄漏。取消注册时释放即可。

四、Lua：上值（Upvalue）

Lua 的所有函数本质上都是闭包。外部局部变量通过**上值（Upvalue）**机制捕获。

4.1 基础

function createCounter()
    local count = 0           -- 局部变量
    return function()
        count = count + 1     -- 捕获外部变量 count
        return count
    end
end

local c1 = createCounter()
print(c1())  -- 1
print(c1())  -- 2
print(c1())  -- 3

local c2 = createCounter()    -- 独立闭包，独立 count
print(c2())  -- 1

4.2 上值共享

-- 同一个外部变量被多个闭包共享
function createPair()
    local val = 0
    return function() val = val + 1; return val end,
           function() val = val - 1; return val end
end

local inc, dec = createPair()
print(inc())  -- 1
print(inc())  -- 2
print(dec())  -- 1   同一个 val！

4.3 Lua 闭包在游戏引擎中的应用

-- 按钮回调
local clickCount = 0
button.onClick = function()
    clickCount = clickCount + 1
    updateUI(clickCount)
end

-- 延时任务
local function afterDelay(seconds, callback)
    -- callback 是闭包，捕获调用处的上下文
    scheduleTimer(seconds, callback)
end

-- 每个调用都有独立的上值
afterDelay(3.0, function() spawnEnemy("goblin") end)
afterDelay(5.0, function() spawnEnemy("orc") end)

五、Python：嵌套函数与 `nonlocal`

5.1 基础闭包

def make_multiplier(factor):
    def multiply(x):
        return x * factor    # factor 被捕获
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)
double(5)   # → 10
triple(5)   # → 15

5.2 `nonlocal`：修改捕获的变量

Python 默认不允许修改外部变量（赋值会创建新的局部变量）。用 nonlocal 声明可以修改：

def counter():
    count = 0
    def increment():
        nonlocal count         # 声明 count 是外部变量，而非局部
        count += 1
        return count
    return increment

c = counter()
c()  # → 1
c()  # → 2

5.3 `closure` 查看捕获

def outer():
    x = 10
    def inner():
        return x
    return inner

fn = outer()
print(fn.__closure__)                     # (<cell at ...: int object at ...>,)
print(fn.__closure__[0].cell_contents)   # 10

六、性能考量

闭包在不同语言中的运行时成本差异巨大，游戏引擎的热路径上需要格外注意。

6.1 C++：近乎零开销……除非用 `std::function`

方式	开销	说明
Lambda + 模板	零	Lambda 是匿名仿函数，编译器知道确切类型，可内联到调用点
Lambda → `std::function`	堆分配 + 虚调用	`std::function` 做类型擦除，小闭包可用 SBO 避免堆分配，但多一层间接调用
引用捕获	无额外开销	引用即指针，但需保证生命周期

// ✅ 零开销：模板参数推导确切类型，内联展开
template<typename F>
void for_each_enemy(F&& fn) { /* ... */ }
for_each_enemy([&](Enemy& e) { e.takeDamage(10); });

// ⚠️ 有开销：std::function 做类型擦除，堆分配 + 虚调用
std::function<void(Enemy&)> callback = [&](Enemy& e) { e.takeDamage(10); };

热路径规则：用模板推导 lambda 而非 std::function 做回调参数。

6.2 C#：堆分配 + GC 压力

C# 闭包会自动将捕获的变量提升到堆上的编译器生成类中：

// 这行代码背后有分配：
Func<int> MakeCounter()
{
    int x = 0;
    return () => ++x;  // C# 编译器生成 class <>c__DisplayClass0 { public int x; }
                       // x 从栈提升到堆！每次调用 MakeCounter 都有 new
}

操作	分配	影响
创建闭包（有捕获）	`new` 编译器生成的类	GC.Alloc ↑
创建闭包（无捕获）	缓存单例，无分配	安全
调用闭包	虚调用（接口方法）	略高于直接调用

// ❌ Update 中每帧创建闭包 → GC 尖峰
void Update() {
    enemies.ForEach(e => e.TakeDamage(10));  // 每帧 new
}

// ✅ 静态无捕获 lambda → 编译器缓存单例，零分配
void Update() {
    enemies.ForEach(static e => e.TakeDamage(10));  // C# 9+ static lambda
}

热路径规则：避免在 Update/FixedUpdate 中创建有捕获的 lambda；优先用 static lambda 或提前缓存委托。

6.3 Lua：闭包创建与 GC

Lua 中每个 function 定义都创建闭包：

-- ❌ 每帧创建闭包 → GC 压力
function updateEnemies()
    for _, e in ipairs(enemies) do
        scheduleTimer(0.5, function() e:attack() end)  -- 每次 schedule 创建闭包
    end
end

-- ✅ 复用函数引用
local function attackEnemy(e)
    return function() e:attack() end
end
-- 仍然会创建闭包（e 是上值），但逻辑清晰

闭包创建：分配内存 + 设置 upvalue → 有 GC 成本
闭包调用：Lua 函数调用本身有寄存器切换开销，upvalue 访问比局部变量慢（间接查表 vs 寄存器）

热路径规则：高频循环内避免创建临时闭包；table.sort、table.foreach 这类带回调的操作，如果回调依赖外部变量，优先传函数引用而非现场构造。

6.4 游戏引擎场景速查

场景	C++	C# (Unity)	Lua
排序/查找（每帧少量）	零开销，放心用	无捕获/static lambda	函数引用
Update 循环回调	零开销（模板）	避免有捕获 lambda	避免创建
延时/异步回调	`std::function` 可接受	接受，注意取消注册	常态用法，注意 GC
事件监听注册	注意生命周期	注意取消注册 + 内存泄漏	注意内存泄漏
超大对象捕获	按引用捕获	编译为字段引用，安全	upvalue，安全但 GC

核心原则：闭包的本质开销不在调用，而在创建时的分配。热路径上控制创建频率 = 控制 GC / 内存抖动。

七、语言对比总结

	C++	C#	Lua	Python
捕获方式	显式 `[捕获列表]`	编译器自动	自动上值	自动
捕获值/引用	程序员控制 `[=]`/`[&]`	引用（变量提升到堆）	引用	引用（`nonlocal` 修改）
底层实现	匿名仿函数对象	编译器生成的闭包类	Lua 闭包 + upvalue 链	`__closure__` 元组
分配开销	零（模板推导）/ 堆分配（`std::function`）	有 GC 分配	有 GC 分配	有 GC 分配
热点安全	模板推导零开销	`static` lambda 无分配	复用函数引用	避免热路径
陷阱	引用捕获生命周期	循环变量共享 + GC 压力	上值共享 + GC 压力	赋值即新建变量

总结

闭包的核心是让函数携带环境，四种语言达成这一目标的方式各有特点。C++ 给予程序员最精细的控制（显式捕获 + 值/引用选择），C# 和 Lua 在游戏开发中对异步与回调的适配最为自然，Python 的简洁特性则在数据处理与工具链中高效。理解闭包变量捕获与生命周期是避免闭包错误（循环变量、悬挂引用）的关键。

在游戏开发语境下，闭包几乎无处不在：以 C++ lambda 简化物理查询或排序；在 Unity 中用 C# 闭包进行事件注册；在 Lua 逻辑层中利用上值构建状态管理；在编辑器工具链中靠 Python 闭包快速开发管线。选用最合适的语言特性写出清晰、高效的闭包代码，才是真正的目的。