Lua与C交互 - 元素码农

发布时间: 2025-03-24 12:15

↑

# Lua与C交互

本文将介绍如何在C/C++程序中嵌入和使用Lua,包括基本API使用、数据交换、函数调用等内容。

## C API基础

### 1. 初始化与关闭

```c
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>

int main() {
    // 创建Lua状态
    lua_State *L = luaL_newstate();
    
    // 加载标准库
    luaL_openlibs(L);
    
    // ... 使用Lua ...
    
    // 关闭Lua状态
    lua_close(L);
    return 0;
}
```

### 2. 栈操作

```c
// 压入值
void push_values(lua_State *L) {
    lua_pushnil(L);        // 压入nil
    lua_pushboolean(L, 1); // 压入true
    lua_pushinteger(L, 42);// 压入整数
    lua_pushnumber(L, 3.14);// 压入浮点数
    lua_pushstring(L, "Hello"); // 压入字符串
}

// 获取值
void get_values(lua_State *L) {
    int index = 1; // 栈索引从1开始
    
    if(lua_isnil(L, index)) {
        // 处理nil
    }
    
    if(lua_isboolean(L, index)) {
        int b = lua_toboolean(L, index);
    }
    
    if(lua_isnumber(L, index)) {
        lua_Integer i = lua_tointeger(L, index);
        lua_Number n = lua_tonumber(L, index);
    }
    
    if(lua_isstring(L, index)) {
        const char *s = lua_tostring(L, index);
    }
}
```

## 数据交换

### 1. 表操作

```c
// 创建表
void create_table(lua_State *L) {
    lua_newtable(L);  // 创建空表
    
    // 设置表字段
    lua_pushstring(L, "name");
    lua_pushstring(L, "Alice");
    lua_settable(L, -3);  // t["name"] = "Alice"
    
    // 简化写法
    lua_pushstring(L, "age");
    lua_pushinteger(L, 20);
    lua_rawset(L, -3);    // t["age"] = 20
}

// 访问表
void access_table(lua_State *L) {
    // 获取全局表
    lua_getglobal(L, "mytable");
    
    // 获取表字段
    lua_getfield(L, -1, "name");
    const char *name = lua_tostring(L, -1);
    lua_pop(L, 1);
    
    // 遍历表
    lua_pushnil(L);  // 第一个键
    while(lua_next(L, -2) != 0) {
        // 键在-2,值在-1
        const char *key = lua_tostring(L, -2);
        const char *value = lua_tostring(L, -1);
        lua_pop(L, 1);  // 保留键用于下一次迭代
    }
}
```

### 2. 用户数据

```c
// 定义结构体
typedef struct Point {
    double x, y;
} Point;

// 创建用户数据
Point *create_point(lua_State *L, double x, double y) {
    Point *p = (Point *)lua_newuserdata(L, sizeof(Point));
    p->x = x;
    p->y = y;
    return p;
}

// 获取用户数据
Point *check_point(lua_State *L, int index) {
    return (Point *)luaL_checkudata(L, index, "Point");
}

// 元方法
static int point_add(lua_State *L) {
    Point *p1 = check_point(L, 1);
    Point *p2 = check_point(L, 2);
    Point *result = create_point(L, p1->x + p2->x, p1->y + p2->y);
    return 1;
}

// 注册元表
void register_point(lua_State *L) {
    luaL_newmetatable(L, "Point");
    
    // 设置元方法
    lua_pushstring(L, "__add");
    lua_pushcfunction(L, point_add);
    lua_settable(L, -3);
}
```

## 函数调用

### 1. C调用Lua函数

```c
// 调用Lua函数
int call_lua_function(lua_State *L) {
    // 获取函数
    lua_getglobal(L, "my_function");
    
    // 压入参数
    lua_pushinteger(L, 10);
    lua_pushstring(L, "hello");
    
    // 调用函数(2个参数,1个返回值)
    if(lua_pcall(L, 2, 1, 0) != 0) {
        printf("Error: %s\n", lua_tostring(L, -1));
        return 1;
    }
    
    // 获取返回值
    int result = lua_tointeger(L, -1);
    lua_pop(L, 1);
    
    return 0;
}
```

### 2. Lua调用C函数

```c
// C函数实现
static int my_function(lua_State *L) {
    // 检查参数
    int n = luaL_checkinteger(L, 1);
    const char *s = luaL_checkstring(L, 2);
    
    // 处理逻辑
    char buffer[256];
    sprintf(buffer, "%s: %d", s, n);
    
    // 返回结果
    lua_pushstring(L, buffer);
    return 1;  // 返回值个数
}

// 注册C函数
void register_function(lua_State *L) {
    // 注册单个函数
    lua_pushcfunction(L, my_function);
    lua_setglobal(L, "my_function");
    
    // 注册函数库
    static const luaL_Reg mylib[] = {
        {"func1", my_function},
        {NULL, NULL}
    };
    
    luaL_newlib(L, mylib);
    lua_setglobal(L, "mylib");
}
```

## 错误处理

### 1. 保护调用

```c
// 保护模式调用函数
void protected_call(lua_State *L) {
    // 设置错误处理函数
    lua_pushcfunction(L, error_handler);
    int errfunc = lua_gettop(L);
    
    // 获取要调用的函数
    lua_getglobal(L, "risky_function");
    
    // 调用函数
    if(lua_pcall(L, 0, 0, errfunc) != 0) {
        printf("Error: %s\n", lua_tostring(L, -1));
    }
    
    lua_remove(L, errfunc);
}

// 错误处理函数
static int error_handler(lua_State *L) {
    const char *msg = lua_tostring(L, 1);
    luaL_traceback(L, L, msg, 1);
    return 1;
}
```

### 2. 异常处理

```c
// 抛出Lua错误
void throw_error(lua_State *L) {
    luaL_error(L, "Something went wrong: %s", "error message");
}

// 检查错误
void check_error(lua_State *L) {
    if(!lua_isstring(L, 1)) {
        luaL_argerror(L, 1, "string expected");
    }
    
    if(some_condition) {
        luaL_error(L, "Invalid operation");
    }
}
```

## 内存管理

### 1. 垃圾回收

```c
// 控制垃圾回收
void gc_control(lua_State *L) {
    // 强制完整GC
    lua_gc(L, LUA_GCCOLLECT, 0);
    
    // 停止GC
    lua_gc(L, LUA_GCSTOP, 0);
    
    // 重启GC
    lua_gc(L, LUA_GCRESTART, 0);
    
    // 获取内存使用量(KB)
    int mem = lua_gc(L, LUA_GCCOUNT, 0);
}
```

### 2. 引用系统

```c
// 创建引用
int create_ref(lua_State *L) {
    // 确保值在栈顶
    return luaL_ref(L, LUA_REGISTRYINDEX);
}

// 获取引用的值
void get_ref(lua_State *L, int ref) {
    lua_rawgeti(L, LUA_REGISTRYINDEX, ref);
}

// 释放引用
void release_ref(lua_State *L, int ref) {
    luaL_unref(L, LUA_REGISTRYINDEX, ref);
}
```

## 调试接口

### 1. 钩子函数

```c
// 调试钩子
static void debug_hook(lua_State *L, lua_Debug *ar) {
    lua_getinfo(L, "nSl", ar);
    printf("Line %d in %s\n", ar->currentline, ar->short_src);
}

// 设置钩子
void set_hook(lua_State *L) {
    lua_sethook(L, debug_hook, LUA_MASKLINE, 0);
}
```

### 2. 获取调试信息

```c
// 获取栈信息
void get_stack_info(lua_State *L) {
    lua_Debug ar;
    int level = 0;
    
    while(lua_getstack(L, level, &ar)) {
        lua_getinfo(L, "nSl", &ar);
        printf("Level %d: %s:%d\n", 
               level, 
               ar.short_src, 
               ar.currentline);
        level++;
    }
}
```

## 最佳实践

### 1. 性能优化

```c
// 预编译Lua代码
void precompile_code(lua_State *L) {
    // 加载并编译代码
    if(luaL_loadstring(L, "function f() return 'hello' end") != 0) {
        printf("Compile error: %s\n", lua_tostring(L, -1));
        return;
    }
    
    // 执行编译后的代码
    if(lua_pcall(L, 0, 0, 0) != 0) {
        printf("Runtime error: %s\n", lua_tostring(L, -1));
        return;
    }
}

// 重用字符串
void string_optimization(lua_State *L) {
    // 将字符串存入注册表
    lua_pushstring(L, "frequently used string");
    int ref = luaL_ref(L, LUA_REGISTRYINDEX);
    
    // 重用字符串
    lua_rawgeti(L, LUA_REGISTRYINDEX, ref);
}
```

### 2. 线程安全

```c
// 创建新线程
lua_State *create_thread(lua_State *L) {
    lua_State *L1 = lua_newthread(L);
    int ref = luaL_ref(L, LUA_REGISTRYINDEX); // 防止被GC
    return L1;
}

// 线程同步
void thread_sync(lua_State *L) {
    lua_lock(L);
    // 临界区操作
    lua_unlock(L);
}
```

## 常见问题

### Q1: 如何处理内存泄漏?

- 确保配对使用push/pop操作
- 正确清理用户数据
- 使用引用系统管理Lua对象
- 定期调用GC

### Q2: 如何优化性能?

- 减少C和Lua之间的数据转换
- 使用正确的API函数
- 预编译经常使用的代码
- 适当控制GC频率

### Q3: 如何保证线程安全?

- 使用lua_lock/lua_unlock
- 避免多线程共享lua_State
- 使用协程代替线程
- 实现proper同步机制

## 下一步

现在你已经了解了Lua与C的交互,可以继续学习[扩展库开发](/article/lua/practice/extension-libs)来了解如何开发Lua的扩展库。

## 参考资源

- [Lua C API 参考手册](http://www.lua.org/manual/5.4