1
2
3
4
5

Lua 代码
    ↓ 调用
绑定层（LuaBridge）
    ↓ 转发
C++ 函数/对象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// C++ 类
class Player {
public:
    int GetLevel() const { return m_nLevel; }
    void SetLevel(int level) { m_nLevel = level; }
    void AddExp(int exp);
    
private:
    int m_nLevel = 1;
    int m_nExp = 0;
};

1
2
3

local player = GetPlayer(10001)  -- C++ 函数返回 Player 对象指针
print(player:GetLevel())         -- 调用 C++ 成员函数
player:SetLevel(10)              -- 调用 C++ 成员函数

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

C 调用 Lua 函数：
1. C 把参数压入栈
2. 调用 lua_call 执行 Lua 函数
3. Lua 函数从栈读取参数
4. Lua 函数把返回值压入栈
5. C 从栈读取返回值

Lua 调用 C 函数：
1. Lua 把参数压入栈
2. Lua VM 调用 C 函数（lua_CFunction）
3. C 函数从栈读取参数
4. C 函数处理、计算结果
5. C 函数把返回值压入栈
6. Lua VM 从栈读取返回值

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

// 栈操作示意图（俯视）
//
//      栈顶                   栈顶
//      ┌───┐                  ┌───┐
//      │ 4 │ ← 索引 -1        │ 4 │ ← 新压入的值在这里
//      ├───┤                  ├───┤
//      │ 3 │ ← 索引 -2        │ 3 │
//      ├───┤                  ├───┤
//      │ 2 │ ← 索引 -3        │ 2 │
//      ├───┤                  ├───┤
//      │ 1 │ ← 索引 -4        │ 1 │
//      └───┘                  └───┘
//      栈底                    栈底
//
// 也可以从栈底索引：1, 2, 3, 4

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// ---- 栈操作 ----
void lua_pushnil(lua_State *L);          // 压入 nil
void lua_pushnumber(lua_State *L, double n); // 压入数字
void lua_pushstring(lua_State *L, const char *s); // 压入字符串
void lua_pushboolean(lua_State *L, int b); // 压入布尔
void lua_pushlightuserdata(lua_State *L, void *p); // 压入指针
void lua_pushcfunction(lua_State *L, lua_CFunction f); // 压入 C 函数

// ---- 取值操作 ----
double lua_tonumber(lua_State *L, int index);      // 从栈读取数字
const char *lua_tostring(lua_State *L, int index);  // 从栈读取字符串
int lua_toboolean(lua_State *L, int index);         // 从栈读取布尔
void *lua_touserdata(lua_State *L, int index);      // 从栈读取指针
int lua_tocfunction(lua_State *L, int index);        // 从栈读取 C 函数

// ---- 类型检查 ----
int lua_type(lua_State *L, int index);              // 获取栈元素类型
int lua_isnil(lua_State *L, int index);
int lua_isnumber(lua_State *L, int index);
int lua_isstring(lua_State *L, int index);

// ---- 函数调用 ----
void lua_call(lua_State *L, int nargs, int nresults);  // 调用 Lua 函数
int lua_pcall(lua_State *L, int nargs, int nresults, int errfunc); // 安全调用

// ---- Table 操作 ----
void lua_gettable(lua_State *L, int index);    // t[key]，key 在栈顶
void lua_settable(lua_State *L, int index);    // t[key]=value
void lua_getfield(lua_State *L, int index, const char *key); // t["key"]
void lua_setfield(lua_State *L, int index, const char *key); // t["key"]=value

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

// C++ 函数
int Add(int a, int b) {
    return a + b;
}

// Lua C API 包装函数
// 所有被 Lua 调用的 C 函数都必须满足这个签名：
// int func(lua_State *L)
int Lua_Add(lua_State *L) {
    // 1. 从栈读取参数
    int a = (int)lua_tonumber(L, 1);  // 第一个参数（索引 1）
    int b = (int)lua_tonumber(L, 2);  // 第二个参数（索引 2）
    
    // 2. 调用真正的 C++ 函数
    int result = Add(a, b);
    
    // 3. 把结果压入栈
    lua_pushnumber(L, result);
    
    // 4. 返回结果数量
    return 1;  // 1 个返回值
}

// 注册到 Lua
void Register(lua_State *L) {
    lua_pushcfunction(L, Lua_Add);    // 压入函数
    lua_setglobal(L, "Add");          // 设为全局变量：_G["Add"] = 函数
}

// ---- 调用绑定类的成员函数就更复杂了 ----

// C++ 类
class Player {
public:
    int GetLevel() { return m_level; }
    void SetLevel(int lv) { m_level = lv; }
private:
    int m_level = 1;
};

// 包装 GetLevel
int Lua_Player_GetLevel(lua_State *L) {
    // 关键问题：这个 Player 对象在哪？
    // 必须从栈上拿到 this 指针
    // 通常用 userdata 或 lightuserdata 来传递 C++ 指针
    
    // 方式一：从轻量 userdata 中取指针
    Player *player = (Player *)lua_touserdata(L, 1);
    // 方式二：从完整 userdata 中取（带 GC 管理）
    // Player *player = *(Player **)lua_touserdata(L, 1);
    
    int level = player->GetLevel();
    lua_pushnumber(L, level);
    return 1;
}

// 包装 SetLevel
int Lua_Player_SetLevel(lua_State *L) {
    Player *player = (Player *)lua_touserdata(L, 1);  // self
    int level = (int)lua_tonumber(L, 2);               // 参数
    player->SetLevel(level);
    return 0;
}

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

用户写的绑定代码：
    luabridge::getGlobalNamespace(L)
        .beginClass<Player>("Player")
        .addConstructor<void(*)()>()
        .addFunction("GetLevel", &Player::GetLevel)
        .addFunction("SetLevel", &Player::SetLevel)
        .endClass();

编译期展开为：
    为 Player::GetLevel 生成一个包装函数
    为 Player::SetLevel 生成另一个包装函数
    在 Lua 中创建一个 metatable，把包装函数挂上去
    注册构造函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// 简化版的 LuaBridge 包装原理

// 第一步：函数签名萃取（编译期）
// 对于函数 Add(int, int) -> int
// 编译器可以萃取出：
//   - 返回类型：int
//   - 参数类型：int, int
//   - 参数数量：2

// 第二步：生成包装器（模板元编程）
template<typename Func>
struct FunctionCaller;

// 特化版本：返回值 void，参数 2 个
template<typename R, typename P1, typename P2>
struct FunctionCaller<R(*)(P1, P2)> {
    // 这个 operator() 就是生成的 lua_CFunction
    static int call(lua_State *L, R(*func)(P1, P2)) {
        // 自动从栈读取参数
        P1 a = Stack<P1>::get(L, 1);  // 编译期根据 P1 类型选择对应的 get 方法
        P2 b = Stack<P2>::get(L, 2);
        
        // 调用真正的函数
        R result = func(a, b);
        
        // 自动将结果压栈
        Stack<R>::push(L, result);
        
        return 1;  // 1 个返回值
    }
};

// 模板化的 C 函数——所有 LuaBridge 绑定的 C++ 函数最终都收敛到这里
template<typename Func>
int InvokeWrapper(lua_State *L) {
    // Lua upvalue 中保存了真正的 C++ 函数指针
    Func func = *static_cast<Func*>(lua_touserdata(L, lua_upvalueindex(1)));
    return FunctionCaller<Func>::call(L, func);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// 每种类型都有对应的栈操作特化
template<typename T>
struct Stack;

// int 类型的特化
template<>
struct Stack<int> {
    static int get(lua_State *L, int index) {
        return (int)lua_tointeger(L, index);
    }
    static void push(lua_State *L, int value) {
        lua_pushinteger(L, value);
    }
};

// float 类型的特化
template<>
struct Stack<float> {
    static float get(lua_State *L, int index) {
        return (float)lua_tonumber(L, index);
    }
    static void push(lua_State *L, float value) {
        lua_pushnumber(L, value);
    }
};

// std::string 类型的特化
template<>
struct Stack<std::string> {
    static std::string get(lua_State *L, int index) {
        size_t len;
        const char *s = lua_tolstring(L, index, &len);
        return std::string(s, len);
    }
    static void push(lua_State *L, const std::string &value) {
        lua_pushlstring(L, value.data(), value.size());
    }
};

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

-- Lua 的原生面向对象：用 metatable 实现类
local Player = {}
Player.__index = Player  -- 当访问不存在的字段时，查 metatable

function Player:new(level)
    local obj = {level = level or 1}
    setmetatable(obj, Player)  -- 设置元表
    return obj
end

function Player:GetLevel()
    return self.level
end

-- 使用
local p = Player:new(10)
print(p:GetLevel())  -- 10
-- p.GetLevel 在 p 本身找不到
-- -> 从 Player 表（p 的 metatable.__index）找到 GetLevel

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// 简化版的 LuaBridge 类绑定代码
template<typename T>
void BindClass(lua_State *L, const char *className) {
    // 1. 创建一个 metatable，用于存储成员函数
    lua_newtable(L);  // metatable 入栈
    
    // 2. 设置 __index 为自身（实现继承查找）
    lua_pushvalue(L, -1);
    lua_setfield(L, -2, "__index");
    
    // 3. 设置 __gc 元方法（用于 C++ 对象生命周期管理）
    lua_pushcfunction(L, &GCObject<T>::gc);
    lua_setfield(L, -2, "__gc");
    
    // 4. 注册到全局表
    lua_setglobal(L, className);
}

// 添加成员函数
template<typename T, typename Func>
void AddFunction(lua_State *L, const char *name, Func T::*method) {
    // 获取全局 metatable
    lua_getglobal(L, "Player");  // Player metatable 入栈
    
    // 创建一个闭包，把成员函数指针作为 upvalue 保存
    lua_pushlightuserdata(L, (void*)&method);  // upvalue
    lua_pushcclosure(L, &MemberInvokeWrapper<T, Func>, 1);
    
    // 设置到 metatable[name]
    lua_setfield(L, -2, name);
    
    // 弹出 metatable
    lua_pop(L, 1);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Lua 中的 Player 对象结构：

    p (userdata)
    │
    └── metatable ──> Player (全局表)
            │
            ├── __index ──> Player (指向自己，形成继承链)
            ├── __gc    ──> Player::~Player (C++ 析构函数)
            ├── GetLevel ──> <CClosure: Lua_Player_GetLevel>
            ├── SetLevel ──> <CClosure: Lua_Player_SetLevel>
            └── ...

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

// 简化版成员函数包装器
template<typename T, typename R, typename... Args>
struct MemberInvoker {
    static int call(lua_State *L) {
        // 从栈的第一个参数（self）取出 C++ 指针
        // Lua 调用 p:GetLevel() 时，self 即 p
        // 等价于 p.GetLevel(p)，第一个参数是 p 自己
        
        T *obj = Userdata<T>::get(L, 1);  // 从 userdata 取出 C++ 指针
        
        // 从 upvalue 取出成员函数指针
        auto method = *static_cast<R(T::**)(Args...)>(lua_touserdata(L, lua_upvalueindex(1)));
        
        // 调用
        R result = (obj->*method)(Stack<Args>::get(L, 2)...);
        
        // 压栈返回值
        Stack<R>::push(L, result);
        return 1;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Lua 栈
┌──────────┐
│ index 1  │ ─── lightuserdata ─── 指针值: 0x00A3F120（Player 对象地址）
├──────────┤
│ index 2  │ ─── number ─── 10（参数 level）
└──────────┘

Userdata<Player>::get(L, 1) 的实现：
    1. 检查栈索引 1 的类型是否是 lightuserdata
    2. 如果是：返回 (Player*)lua_touserdata(L, 1)
    3. 如果不是：报错 "参数类型错误"

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

// 绑定构造函数：.addConstructor<void(*)()>()
// 实际上注册了一个"工厂函数"到 Lua

template<typename T>
int ConstructorWrapper(lua_State *L) {
    // 1. 在堆上分配 C++ 对象
    T *obj = new T();
    
    // 2. 创建 userdata，把指针存进去
    // 注意：这里用的是完整 userdata（不是 lightuserdata）
    // 完整 userdata 关联了 metatable，可以设置 __gc 回调
    void *storage = lua_newuserdata(L, sizeof(T*));
    *(T**)storage = obj;  // 存入 C++ 指针
    
    // 3. 设置 metatable（这样才能调用成员函数！）
    lua_getglobal(L, "Player");  // 获取 Player 的 metatable
    lua_setmetatable(L, -2);     // 设置给新创建的 userdata
    
    return 1;  // 返回 userdata（Lua 拿到的就是"Player 对象"）
}

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

// Lua GC 回收 userdata 时会触发 __gc
// 对应 metatable 的 __gc 回调
template<typename T>
int GCObject<T>::gc(lua_State *L) {
    // 从 userdata 取出 C++ 指针
    T *obj = *(T**)lua_touserdata(L, 1);
    
    // 调用 C++ 析构函数，释放内存
    delete obj;
    
    return 0;
}

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

// C++ 中有多个同名的函数
class Player {
public:
    void SetLevel(int level);
    bool SetLevel(const char *name);  // 重载
};

// LuaBridge 绑定
luabridge::getGlobalNamespace(L)
    .beginClass<Player>("Player")
    .addFunction("SetLevel", 
        (void(Player::*)(int))&Player::SetLevel)  // 用类型转换区分重载
    .addFunction("SetLevelByName", 
        (bool(Player::*)(const char*))&Player::SetLevel)
    .endClass();

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

class Player {
public:
    void AddExp(int exp, bool notify = true);  // 默认参数
};

// LuaBridge 绑定
// 默认参数不会被自动处理！因为 C++ 的默认参数是编译期行为
// LuaBridge 看到的函数签名是 void(Player::*)(int, bool)

// 解决方法：提供一个去掉默认参数的包装
void Player_AddExp(Player *p, int exp) {
    p->AddExp(exp, true);  // 在包装里写死默认值
}

luabridge::getGlobalNamespace(L)
    .beginClass<Player>("Player")
    .addFunction("AddExp", Player_AddExp)  // 用自由函数包装
    .endClass();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// C++ 全局函数
Entity* GetPlayer(int64_t playerId);
Entity* GetMonster(int64_t monsterId);

// LuaBridge 绑定
luabridge::getGlobalNamespace(L)
    .addFunction("GetPlayer", GetPlayer)
    .addFunction("GetMonster", GetMonster);

// Lua 中使用
local player = GetPlayer(10001)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// ─── C++ 类 ───
class Player : public Entity {
public:
    // 属性和方法
    int64_t GetId() const { return m_nId; }
    const std::string& GetName() const { return m_strName; }
    void SetName(const std::string &name) { m_strName = name; }
    
    // 静态方法
    static Player* GetPlayerById(int64_t id);
    
    // 运算符重载
    bool operator==(const Player &other) const { return m_nId == other.m_nId; }
    
private:
    int64_t m_nId;
    std::string m_strName;
};

// ─── LuaBridge 绑定 ───
luabridge::getGlobalNamespace(L)
    .beginNamespace("Game")              // 命名空间：Game
        .beginClass<Player>("Player")    // 类：Game.Player
            .addConstructor<void(*)()>()  // 构造函数
            .addProperty("id", &Player::GetId)           // 只读属性
            .addProperty("name", &Player::GetName, &Player::SetName)  // 读写
            .addFunction("GetPlayerById", &Player::GetPlayerById)     // 静态方法
            .addFunction("__eq", &Player::operator==)    // 运算符重载
        .endClass()
    .endNamespace();

// Lua 中使用
local p = Game.Player()
p.name = "张三"
print(p.id, p.name)       -- 10001 张三
local p2 = Game.Player.GetPlayerById(10001)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// C++ 侧——调用 Lua 函数
class Player {
public:
    void OnLevelUp() {
        // 从全局 _G 表中取 Lua 函数
        LuaEngine::Get()->CallGlobalLuaFunction("event.OnPlayerLevelUp", m_nId, m_nLevel);
    }
};

// LuaEngine::CallGlobalLuaFunction 的实现
void LuaEngine::CallGlobalLuaFunction(const char *name, int64_t playerId, int level) {
    lua_State *L = m_pLuaState;
    
    // 1. 获取 Lua 函数
    lua_getglobal(L, name);  // 查找 _G["event.OnPlayerLevelUp"]
    
    if (!lua_isfunction(L, -1)) {
        // 函数不存在，说明 Lua 侧没有注册这个事件
        lua_pop(L, 1);
        return;
    }
    
    // 2. 压入参数
    lua_pushinteger(L, playerId);  // 第一个参数
    lua_pushinteger(L, level);     // 第二个参数
    
    // 3. 调用（2个参数，0个返回值）
    if (lua_pcall(L, 2, 0, 0) != LUA_OK) {
        const char *err = lua_tostring(L, -1);
        LogError("Lua 调用失败: %s", err);
        lua_pop(L, 1);
    }
}

// Lua 侧注册事件
event.OnPlayerLevelUp = function(playerId, level)
    print("玩家", playerId, "升级到", level, "级！")
    -- 触发升级奖励、任务检查等
end

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

// 场景 1：Lua 创建，Lua 管理（配合 __gc）
// C++ new 出来的对象，存储在完整 userdata 里
// Lua GC 回收 userdata 时触发 __gc → delete 对象
// ✅ 安全，不会泄漏

// 场景 2：C++ 创建，Lua 使用
// C++ 层维护的对象池 / 缓存
// Lua 拿到的是 lightuserdata（就是一个指针，没有 metatable）
// 不触发 __gc，C++ 侧管理生命周期
// ✅ 安全，但不能让 Lua 持有指针超过 C++ 对象的生命周期

// 场景 3：C++ 创建，Lua 拥有
// 用完整 userdata 包装，但需要设置正确的 __gc
// Lua 持有引用期间 C++ 对象存活
// ⚠ 注意：如果 C++ 还有其他持有者，要防止 double free！

// 项目中推荐的方案：
// 场景 2 最常用——实体由 C++ EntityManager 统一管理
// Lua 只拿指针来"访问"，不负责释放

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

// 项目中 Entity 的管理方式
class EntityManager {
    std::unordered_map<int64_t, Entity*> m_entities;
public:
    Entity* GetEntity(int64_t id) {
        auto it = m_entities.find(id);
        return it != m_entities.end() ? it->second : nullptr;
    }
    
    void AddEntity(Entity *entity) {
        m_entities[entity->GetId()] = entity;
    }
    
    void RemoveEntity(int64_t id) {
        m_entities.erase(id);
        // 注意：实体可能还被 Lua 引用着！
        // 但 Lua 里的是 lightuserdata，只是个指针
        // 如果 Lua 在实体销毁后继续访问 → 崩溃！
        // 所以需要在 Lua 侧检测有效性
    }
};

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

-- Lua 侧的安全访问模式
function SafeCall(entity, method, ...)
    if entity == nil then
        return nil, "entity is nil"
    end
    -- 调用之前不能保证 entity 还在，所以加保护
    local ok, result = pcall(method, entity, ...)
    if not ok then
        print("实体已失效:", result)
        return nil
    end
    return result
end

-- 使用
local player = GetPlayer(10001)
SafeCall(player, player.GetLevel)

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

Lua → C++ 函数调用开销分解：
1. Lua 参数压栈          ← Lua VM 内部
2. 查找 C 函数并跳转      ← Lua VM 内部
3. C 函数从栈读参数       ← 参数数量越多越慢
4. 调用真正的 C++ 函数    ← 真正的业务
5. C 函数把结果压栈       ← 返回值越多越慢
6. Lua 获取返回值         ← Lua VM 内部

每步开销（Lua 5.3 测试数据）：
- 无参数无返回值的 C 函数调用：约 80ns
- 4 个 int 参数：约 120ns
- 1 个 string 参数（短字符串）：约 150ns（+字符串拷贝）
- 类的成员函数调用：约 100ns

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

-- ❌ 坏：频繁跨语言调用
function UpdatePlayer(player)
    local hp = player:GetHp()     -- C++ 调用
    local maxHp = player:GetMaxHp()  -- C++ 调用
    local mp = player:GetMp()     -- C++ 调用
    local maxMp = player:GetMaxMp() -- C++ 调用
    local atk = player:GetAtk()   -- C++ 调用
    local def = player:GetDef()   -- C++ 调用
    
    if hp < maxHp * 0.3 then
        player:UseHealPotion()    -- C++ 调用
    end
end
-- 每帧 7 次 C++ 调用

-- ✅ 好：批量获取
-- 在 C++ 侧提供一个批量获取属性的函数
-- Player::GetAllAttrs() 返回一个结构体或 Table
function UpdatePlayer(player)
    local attrs = player:GetAllAttrs()  -- 1 次 C++ 调用拿到所有属性
    -- attrs 是 Lua Table，后续访问是纯 Lua 操作
    
    if attrs.hp < attrs.maxHp * 0.3 then
        player:UseHealPotion()
    end
end
-- 只有 2 次 C++ 调用

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

// ❌ 慢：传递 Lua Table 作为参数
// C++ 侧需要遍历 Table，每次读取都要走 C API
void ProcessItems_Cpp(lua_State *L) {
    lua_getfield(L, 1, "items");  // 获取第一个参数的 items 字段
    int n = lua_rawlen(L, -1);     // 数组长度
    
    for (int i = 1; i <= n; i++) {
        lua_rawgeti(L, -1, i);    // 每次读一个元素
        int id = (int)lua_tointeger(L, -1);
        lua_pop(L, 1);
        
        ProcessItem(id);
    }
}

// ✅ 快：传基本类型或指针
// 用多个参数代替 Table
void ProcessItems_Fast(int64_t *ids, int count) {
    for (int i = 0; i < count; i++) {
        ProcessItem(ids[i]);
    }
}

1
2
3
4
5
6
7
8

-- ❌ 慢
player:ProcessItems({items = {1001, 1002, 1003}})

-- ✅ 快：一个一个调，或者用 C 数组
-- 但一个一个调增加调用次数，需要权衡
-- 最佳方案：在 C++ 侧提供一个接受多参数的重载
player:ProcessItems(1001, 1002, 1003)
-- 或者在 C++ 侧使用 va_list / 数组参数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 每次通过 LuaBridge 调用成员函数，实际路径：
// Lua 调用 → lua_CFunction（包装器）
//          → 从栈读 self（类型检查）
//          → 从 upvalue 读成员函数指针
//          → 从栈读参数（每个参数类型检查 + 转换）
//          → 调用 C++ 函数
//          → 返回值压栈

// 类型检查由 LuaBridge 的 lua_type 调用完成
// 可以在 Release 版本中跳过某些检查以提升性能
// 但这需要修改 LuaBridge 源码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// 经验 1：批量操作接口
// 不要每个属性一个 Getter
class Player {
    // ❌
    int GetHp();
    int GetMaxHp();
    int GetMp();
    int GetMaxMp();
    int GetAtk();
    int GetDef();
    
    // ✅
    void GetBattleAttrs(BattleAttrs &out);  // 一次调用全部获取
};

// 经验 2：热点路径减少跨语言调用
// 战斗计算中的每帧循环——让 C++ 处理
// 不要在 Lua 里每帧遍历所有技能打 C++ 回调
// 应该把整段循环逻辑 if 可能放在 C++ 侧

// 经验 3：String 参数的拷贝问题
// Lua → C++ 传递字符串时，会拷贝字符串内容
// 频繁传递大字符串是性能杀手
// 用整数 ID 代替字符串传递
// 或者在 C++ 侧缓存字符串的引用

// 经验 4：C++ 调用 Lua 回调的优化
// 如果某个事件频繁触发（如每秒触发一次），
// 在 C++ 侧缓存 Lua 函数的引用（注册时取引用），
// 而不是每次都 lua_getglobal 查找
class EventSystem {
    int m_callbackRef = LUA_NOREF;  // Lua registry 引用
    
    void RegisterCallback(lua_State *L) {
        lua_pushvalue(L, -1);  // 复制栈顶的函数
        m_callbackRef = luaL_ref(L, LUA_REGISTRYINDEX);  // 存入 registry
    }
    
    void FireEvent(lua_State *L, int arg) {
        if (m_callbackRef != LUA_NOREF) {
            lua_rawgeti(L, LUA_REGISTRYINDEX, m_callbackRef);  // 直接取引用
            lua_pushinteger(L, arg);
            lua_pcall(L, 1, 0, 0);
        }
    }
};

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

// 错误：基类未注册就注册子类
luabridge::getGlobalNamespace(L)
    .beginClass<Player>("Player")  // Player 继承自 Entity
    // Entity 还没注册！
    .addFunction("GetLevel", &Player::GetLevel)
    .endClass();

// 正确：先注册基类，再注册子类
luabridge::getGlobalNamespace(L)
    .beginClass<Entity>("Entity")
        .addFunction("GetId", &Entity::GetId)
    .endClass()
    
    .deriveClass<Player, Entity>("Player")  // 声明继承关系
        .addFunction("GetLevel", &Player::GetLevel)
    .endClass();

1
2
3
4
5
6

local player = GetPlayer(10001)  -- 返回 lightuserdata
local monster = GetMonster(20001)  -- 也是 lightuserdata

-- 如果把 monster 误传给需要 Player 参数的 C++ 函数
player:GetLevel()  -- OK
monster:GetLevel()  -- ❌ 如果 Monster 没有 GetLevel，崩溃或返回 nil

1
2
3
4

local player = GetPlayer(10001)
-- 如果玩家在别的线程被删除了，而 Lua 还持有指针

player:GetLevel()  -- 崩溃！player 已经是野指针

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 绑定层加保护
int Lua_Player_GetLevel(lua_State *L) {
    Player *player = Userdata<Player>::get(L, 1);
    if (!player) {
        lua_pushnil(L);  // 返回 nil 而不是崩溃
        return 1;
    }
    lua_pushinteger(L, player->GetLevel());
    return 1;
}

1
2
3
4
5
6

Lua C API        ← 底层基础：栈操作、函数调用、userdata
LuaBridge        ← 上层封装：模板元编程自动化包装
   ├── 函数包装  ← 编译期萃取签名，自动生成入参/出参代码
   ├── 类绑定    ← metatable + userdata 实现面向对象
   ├── 生命周期  ← __gc 回调管理 C++ 对象释放
   └── 性能      ← 跨语言调用有成本，批量操作减少调用次数