Lua/c接口编程是skynet的核心技能开发，主要涉及到Lua调C语言和C语言调用Lua的工作流程。从而开发属于自己的组件。

Lua/c接口编程主要掌握Lua和C语言之间它们是怎么交互的。skynet、openresty 都是深度使用 lua 语言的典范；学习 lua 不仅仅要学习基本用法，还要学会使用 c 与 lua 交互，这样才学会了 lua 作为胶水语言的精髓。

openresty(nginx + lua)：openresty使用多进程，每个进程都有自己的lua虚拟机。

skynet中调用层次：skynet是多线程的，actor的调度和执行由线程池分配。

wget -c http://www.lua.org/ftp/lua-5.3.0.tar.gz
tar zxvf lua-5.3.0.tar.gz

cd lua-5.3.0
make linux
sudo make install

Lua 5.3.0 Copyright (C) 1994-2015 Lua.org, PUC-Rio 
>print("Hello World!") 
Hello World!

对lua不熟悉可以查看Lua参考手册查看接口函数，里面都提供了c语言的api和lua的api。

c代码只需要编译一次，lua可以随时改动；因为lua是动态语言。嵌入lua的好处是c只需要写一次代码，编译一次程序，所有的变化都可以通过修改lua的代码，重启程序就可以了。当然，也可以在c语言里面添加逻辑实现自动检测lua文件的改变并自动加载新的lua文件。

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

（2）创建lua虚拟机和加载lua库：

lua_State *L=luaL_newstate();   //创建lua虚拟机
luaL_openlibs(L);               //加载lua库，比如math库、table库等

（3）加载lua文件到c语言的内存空间：

luaL_dofile(L,filename);  //加载lua文件到c语言内存中，进行语法检查，不会编译

（4）取全局变量并压栈传参数：

lua_getglobal(L, func_name); // 查找lua文件中的全局函数，并压入虚拟栈
lua_pushinteger(L, 1);      // 压栈，传入参数

（4）执行函数，lua_call 的参数中第二个是参入参数个数，第三个是返回值个数：

lua_call(L, 1, 0);          // 栈弹出，执行函数

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

static void call_func(lua_State *L, const char* funcname)
{
    lua_getglobal(L, funcname); // 查找lua文件中的全局函数，并压入虚拟栈
    lua_pushinteger(L, 1);      // 压栈，传入参数
    lua_call(L, 1, 0);          // 调用方法
}

int main(int argc,char **argv)
{
    lua_State *L=luaL_newstate();   //创建lua虚拟机
    luaL_openlibs(L);               //加载lua库，比如math库、table库等

    if(argc>1)
    {
        lua_pushboolean(L,1);
        lua_setfield(L,LUA_REGISTRYINDEX,"LUA_NOENV");
        if(LUA_OK!=luaL_dofile(L,argv[1]))  //加载lua文件到c语言内存中，进行语法检查，不会编译
        {
            const char * err=lua_tostring(L,-1);
            fprintf(stderr,"err:\t%s\n",err);
            return -1;
        }
    }
    
    // 执行lua的方法、函数
    call_func(L, "Init");
    call_func(L, "Loop");
    call_func(L, "Release");

    // 删除虚拟机
    lua_close(L);

    return 0;
}

package.cpath = "luaclib/?.so"

function Init(args)
    print("call [init] function", args)
end

function Loop()
    print("call [loop] function")
    for k, v in ipairs({1,2,3,4,5}) do
        print("value = " .. v)
    end
end

function Release()
    print("call [release] function")
end

call [init] function    1
call [loop] function
value = 1
value = 2
value = 3
value = 4
value = 5
call [release] function

lua只识别动态库，c语言需要编译被调用模块，然后编译成动态库。

那么lua怎么识别c语言的动态库的函数呢？lua只识别以luaopen开头的函数。

static int
lecho (lua_State *L) {
    const char* str = lua_tostring(L, -1);
    fprintf(stdout, "%s\n", str);
    return 0;
}

（2）创建一个导出给lua使用的数组，类型是luaL_Reg。

static const luaL_Reg l[] = {// 导出给lua使用数组
	{"echo", lecho},
	{NULL, NULL},
};


（3）c语言实现一个luaopen开头的函数，创建一张新的表，并预分配足够保存下函数指针数组内容的空间。

int
luaopen_tbl_c(lua_State *L) { // local tbl = require "tbl.c"
    // 创建一张新的表，并预分配足够保存下数组 l 内容的空间
	// luaL_newlibtable(L, l);
	// luaL_setfuncs(L, l, 0);
    luaL_newlib(L, l);
	return 1;
}

（4）lua中导入c语言动态库并使用函数。

package.cpath = "luaclib/?.so"
local so = require "tbl.c"

（5）编译c语言函数为动态库。

（1）lua首先会进行动态库的导入，即

（2）Lua就会去查找动态库中以luaopen_*开头的函数，*就是展开了的c文件名，比如展开为luaopen_table_c的函数名。

（3）找到函数后就执行函数，函数里面新建了一张函数地址表（函数数组），然后以table形式传给变量so。

（4）接下来就可以使用c语言的函数了。

注意：在Linux上直接使用apt-get安装的lua是没有自动安装lua库的，需要下载lua的源码编译安装。

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

#include <stdio.h>

static int
lecho (lua_State *L) {
    const char* str = lua_tostring(L, -1);
    fprintf(stdout, "%s\n", str);
    return 0;
}

static const luaL_Reg l[] = {// 导出给lua使用数组
	{"echo", lecho},
	{NULL, NULL},
};

int
luaopen_tbl_c(lua_State *L) { // local tbl = require "tbl.c"
    // 创建一张新的表，并预分配足够保存下数组 l 内容的空间
	// luaL_newlibtable(L, l);
	// luaL_setfuncs(L, l, 0);
    luaL_newlib(L, l);
	return 1;
}


package.cpath = "luaclib/?.so"
local so = require "tbl.c"

function Init(args)
    print("call [init] function", args)
end

function Loop()
    print("call [loop] function")
    for k, v in ipairs({1,2,3,4,5}) do
        so.echo(v)
    end
end

function Release()
    print("call [release] function")
end


# $@ 目标文件 $^ 所有的依赖文件 $< 第一个依赖文件
# -Wl,-E 

PLAT ?= linux

# 在Makefile中，.PHONY后面的target表示的也是一个伪造的target, 而不是真实存在的文件target；
# 注意Makefile的target默认是文件。 shell
.PHONY : clean all cleanall

LUA_CLIB_PATH ?= luaclib
LUA_CLIB_SRC ?= lualib-src
# LUA_CLIB = tbl uv reg1 reg2 ud
LUA_CLIB = tbl
LUA_INC ?= ./lua/src

SHARED := -fPIC --shared
EXPORT := -Wl,-E
ifeq ($(PLAT), macosx)
	SHARED := -fPIC -dynamiclib -Wl,-undefined,dynamic_lookup
endif

CFLAGS = -g -O2 -Wall -I$(LUA_INC)
CC ?= gcc

LUA_STATICLIB := lua/src/liblua.a

all : \
	$(LUA_STATICLIB) \
	test-vm \
	$(foreach v, $(LUA_CLIB), $(LUA_CLIB_PATH)/$(v).so)

$(LUA_STATICLIB) :
	cd lua && $(MAKE) CC='$(CC) -std=gnu99' $(PLAT)

test-vm : test-vm.c
	$(CC) $(CFLAGS) $^ -o $@ -L$(LUA_INC) $(EXPORT) -llua -ldl -lm

$(LUA_CLIB_PATH) :
	mkdir -p $(LUA_CLIB_PATH)

$(LUA_CLIB_PATH)/tbl.so : $(LUA_CLIB_SRC)/lua-tbl.c | $(LUA_CLIB_PATH)
	$(CC) $(CFLAGS) $(SHARED) $^ -o $@ 

clean:
	rm -f $(LUA_CLIB_PATH)/*.so
	rm -f test-vm

cleanall :
	rm -f $(LUA_CLIB_PATH)/*.so
	cd lua && $(MAKE) clean
	rm -f test-vm


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

#include <stdio.h>

// 闭包实现：  函数 + 上值  luaL_setfuncs
// lua_upvalueindex(1)
// lua_upvalueindex(2)
static int
lecho (lua_State *L) {
	lua_Integer n = lua_tointeger(L, lua_upvalueindex(1));
    n++;
    const char* str = lua_tostring(L, -1);
    fprintf(stdout, "[n=%lld]---%s\n", n, str);
    lua_pushinteger(L, n);
    lua_replace(L, lua_upvalueindex(1));// 更新UpValue
    return 0;
}

static const luaL_Reg l[] = {
	{"echo", lecho},
	{NULL, NULL},
};

int
luaopen_uv_c(lua_State *L) { // local tbl = require "tbl.c"
	luaL_newlibtable(L, l);// 1
    lua_pushinteger(L, 0);// 2 ,绑定上值UpValue
	luaL_setfuncs(L, l, 1);// 上值
    // luaL_newlib(L, l);
	return 1;
}


package.cpath = "luaclib/?.so"

local so = require "uv.c"

so.echo("hello world1")
so.echo("hello world2")
so.echo("hello world3")
so.echo("hello world4")
so.echo("hello world5")
so.echo("hello world6")
so.echo("hello world7")
so.echo("hello world8")
so.echo("hello world9")

--./lua/src/lua test-uv.lua

[n=1]---hello world1
[n=2]---hello world2
[n=3]---hello world3
[n=4]---hello world4
[n=5]---hello world5
[n=6]---hello world6
[n=7]---hello world7
[n=8]---hello world8
[n=9]---hello world9

userdata 是指向一块内存的指针，该内存由 lua 来创建，通过void *lua_newuserdatauv(lua_State *L, size_t sz,int nuvalue) 这个函数来创建。

注意：这块内存大小必须是固定的，不能动态增加，但是这块内存中的指针指向的数据可以动态增加

。lua 5.4的 userdata 可以绑定若干个 lua 值（又称uservalue）。

userdata 与 uservalue 的关系是引用关系，也就是 uservalue 的生命周期与 userdata 的生命周期一致。

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct log {
    int count;
};

static int
lagain(lua_State *L) {
    struct log *p = (struct log *)luaL_checkudata(L, 1, "ud.log");	//检查userdata, 返回userdata地址
    lua_getuservalue(L, -1);
    const char* str = lua_tostring(L, -1);
    fprintf(stdout, "ud[n=%d]----%s\n", p->count, str);
    return 0;
}

static int
lecho(lua_State *L) {
    struct log *p = (struct log *)luaL_checkudata(L, 1, "ud.log");//检查userdata, 返回userdata地址
    const char* str = lua_tostring(L, -1);	// 获取UpValue
    p->count++;
    lua_setuservalue(L, -2);
    fprintf(stdout, "ud[n=%d]----%s\n", p->count, str);
	return 0;
}

static int
lnew (lua_State *L) {
	// lua虚拟机分配一块内存作为userdata的空间
    struct log *q = (struct log*)lua_newuserdata(L, sizeof(struct log));
    q->count = 0;
    lua_pushstring(L, "");		//绑定UpValue，初始值是“”
    lua_setuservalue(L, -2);	// 从栈上弹出一个值并将其设为给定索引处用户数据的关联值
	if (luaL_newmetatable(L, "ud.log")) {	// 如果注册表中已存在键 "ud.log"，返回0。 否则为用户数据的元表创建一张新表
        // 数组保存函数地址
        luaL_Reg m[] = {
			{"echo", lecho},
            {"again", lagain},
			{NULL, NULL},
		};
		//  创建一张新的表，并预分配足够保存下数组 m 内容的空间
		luaL_newlib(L, m);
		// 设置元表__index段，而 -2是栈顶的索引对应的那个值，当key不存在或不是表时调用m表。
		lua_setfield(L, -2, "__index");
        lua_setmetatable(L, -2);
    }
    return 1;
}
// 数组 l 内容,保存函数地址
static const luaL_Reg l[] = {
	{"new", lnew},
	{NULL, NULL},
};

int
luaopen_ud_c(lua_State *L) {
	//  创建一张新的表，并预分配足够保存下数组 l 内容的空间
    luaL_newlib(L, l);
	return 1;
}


package.cpath = "luaclib/?.so"

local so = require "ud.c"

local ud = so.new()

ud:echo("hello world1")
ud:again()
ud:echo("hello world2")
ud:again()
ud:echo("hello world3")
ud:again()
ud:echo("hello world4")
ud:again()
ud:echo("hello world5")
ud:again()
ud:echo("hello world6")
ud:again()
ud:echo("hello world7")
ud:again()
ud:echo("hello world8")
ud:again()
ud:echo("hello world9")
ud:again()

--./lua/src/lua test-ud.lua

[n=1]---hello world1
[n=1]---hello world1
[n=2]---hello world2
[n=2]---hello world2
[n=3]---hello world3
[n=3]---hello world3
[n=4]---hello world4
[n=4]---hello world4
[n=5]---hello world5
[n=5]---hello world5
[n=6]---hello world6
[n=6]---hello world6
[n=7]---hello world7
[n=7]---hello world7
[n=8]---hello world8
[n=8]---hello world8
[n=9]---hello world9
[n=9]---hello world9

可以用来在多个 c 库中共享 lua 数据（包括 userdata 和lightuserdata ）。

Lua有一个全局表，有一个LUA_REGISTRYINDEX的key，LUA_REGISTRYINDEX的value又是一个表，专门用来存放全局数据（[key]=userdata）。

Lua与C语言接口编程实战指南：打造高性能、灵活的程序

详解Lua和C语言之间它们是怎么交互的，涵盖c语言与lua直接的函数互相调用，以及lua的user data、注册表等在c语言的使用，提供完整的使用示例。

编程语言

开发工具

后端

本文介绍Lua/C接口编程，涵盖环境搭建、虚拟栈、C与Lua相互调用、闭包、userdata及注册表使用，还提及热更新，助开发者掌握Lua作为胶水语言精髓。

虚拟机

Linux

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

Lua与C语言接口编程实战指南：打造高性能、灵活的程序

Lua与C语言接口编程实战指南：打造高性能、灵活的程序

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐