Cleofwine | 开发者

游戏后端技术_Lua程序设计

最近更新：2024-09-23 | 字数总计：5k | 阅读估时：22分钟 | 阅读量：次

什么是lua
使用lua
lua入门
lua控制结构
编译以及错误处理
模块和包
元表和元方法
lua环境
lua/C接口编程

什么是lua

脚本语言，c实现
应用：嵌入式、物联网、游戏、软件安全、机器学习等领域
redis、openresty、WOW、openWt、PhotoShop方便开发者进行功能扩展和二次开发
热更新、不停机部署
luajit（预编译接近c的性能，但是有限制）

使用lua

编译+安装

wget https://lua.org/ftp/lua-5.4.6.tar.gz
tar -xzvf lua-5.4.6.tar.gz
cd lua-5.4.6
make linux
make install
lua "print 'hello world'"

lua 解析器
加载lua虚拟机（嵌入C）

lua入门

注释
全局变量
- 无需声明即可使用
- 未初始化，值为 nil
类型和值
- nil
  1. 不存在（无效）
  2. 未定义
- boolean
  1. true
  2. false
  3. 为了区分nil的两个语义
  4. 条件控制中，false和nil之外为真（特别：0为真）
  5. 逻辑运算符（and or not）：遵循短路求值
  6. 三目运算符： a and b or c （相当于 a?b:c，但是有特殊规则）
  7. not返回boolean类型的值
- number（不区分浮点数和整数，都是number类型）
  1. integer
  2. float
- string
  1. 不可变值，不可以更改某个字符串中的某个字符
  2. 长字符串[[]]
  3. 字符串拼接..,允许拼接整数
  4. #字符串，可以取字符串长度
- function
  1. 第一类值
    1. 与数值、字符串具有同等的权限
    2. 可以保存在变量中，表中
    3. 作为参数传递给其他函数
    4. 作为其他函数的返回值
  2. 可以多返回值
  3. 可变厂参数
    1. select(“#”, …)
    2. select(1, …)
  4. 尾递归(尾调用消除)
  5. 闭包
    1. 函数内部可以访问函数外部的变量
    2. c函数 + upvalues数组实现的
  6. 语法糖
    1. local function funname () … end 相当于 local funname 然后 funname = function() … end
- table
  1. lua中唯一的数据结构
  2. 可以表示数组、集合、记录、包
  3. 只能操作表的引用，当表没有引用的时候，gc会自动删除该表占用的空间
  4. 数组索引从1开始
  5. 语法糖
    1. 数组语法糖 local array = {1,2,3,4,5}
    2. 表语法糖 tab.name <==> tab[“name”]
    3. #取长度运算符，取数组的长度

-- hello
-- [[
 注释
]]

local i = 1 -- 局部变量
i2 = 2  -- 全局变量
function sum(a, b)
    sum = a+b -- 局部变量
    return sum
end

local tab = {}
-- 区分不存在和未定义
print(tab["name"]) -- nil

local tab2 = {name = false}
print(tab["name"]) -- false

-- nil和false才会为假
-- 0是真
if not tab.name then
    print("tab.name is nil or false")
end

local isOK = nil and 0 -- nil 根据短路求值
local isOK2 = 0 or nil -- 0 根据短路取值
local isOK3 = 0 and 5 or 3 -- 5 三目运算符
local isOK4 = false and 5 or 3 -- 3 三目运算符
local isOK5 = 0 and nil or 4 -- 4 三目运算符特殊规则

local str1 = "hello world"
local str2 = str1:gsub("world", "lin")
print(str1, str2)

local str3 = [[
hello world1
hello world2
hello world3
]]
-- 长字符串表示法

print(str1..","..str2) -- 字符串拼接
print(str1..100..str2) -- 字符串拼接

local func = function (a, b)
    return a+b
end
func(1,2) -- 3

local func2 = function(tab, func)
    for k,v in pairs(tab) do
        print(v, func(v))
    end
end

local func_base = function(a)
    return a+5
end

local func_base2 = function(a)
    return func(a, 5)
end

print(func2({1,2,3,4,5}, func_base))
print(func2({1,2,3,4,5}, func_base2))

local tab = {}
tab.func = function () 
 -- ...
end

--[[
    模块的一般写法
    local tab = {}
    function tab.func()
        ...
    end
    return tab
]]

-- 多返回值
local function mreturn()
    return 1,2
end
local a,b = mreturn()

-- 可变参数
local function mparams(...)
    local len = select("#", ...)
    local sum = 0
    for i=1, len do
        sum = sum + select(i, ...)
    end
    return sum
end
print(mparams(1,2,3,4,5,6,7))

-- 语法糖
local func3 function()
end
-- 相当于
local func3
func3 = function()
end

-- 尾递归(尾调用消除)，这里会自动进行尾调用消除，节省栈空间
local function factorial(n, total)
    if n == 1 then
        return total
    end
    return factorial(n-1, n * total)
end
print(factorial(5, 1)) -- 5*4*3*2*1

-- 闭包
local function counter()
    local init = 0
    return function()
        init = init + 1
        return init
    end
end
local cutfunc = counter()
print(cutfunc()) -- 1
print(cutfunc()) -- 2
print(cutfunc()) -- 3
print(cutfunc()) -- 4

-- table：数组 起始索引 是 1
local array = {1,2,3,4,5,6}
array = {1, func2, fun3, 3,4, 5}
for k, v in ipairs(array) do
    print(k, v)
end
-- table ：操作的是引用
local function modify(arr)
    arr[#arr] = cntfunc -- #arr相当于数组的长度，也就是最后一个位置
end
modify(array)
for _, v in ipairs(array) do
    print(v) -- 最后一个位置的值会改变
end
-- 语法糖
local tab3 = {["name"] = "lin", sex = female}
tab3.age = "29" -- tab3["age"] = "29"


-- 这种情况不能使用#arr
local tab4 = {1,2,nil,3,4} -- 不行
local tab5 = {1,2,false,3,4} -- 这个可以

lua控制结构

与其他语言的差异
1. 不提供continue
2. 不支持switch
3. 条件表达式中，只有nil和false为假，其他为真；例如，0和“”都是真
if then else
1. 嵌套if语句中使用elseif（对应一个then）
2. 可以使用table实现switch语句
while
1. 只要条件满足就一直执行
repeat until
1. 一直执行直到条件满足
2. 可以实现continue
for
1. 数值型
2. 泛型
break,return,goto
1. break退出当前循环
2. return结束函数运行
  1. 代码块的最后一句
  2. end之前的最后一句
  3. else之前的最后一句
  4. until之前的最后一句
3. goto跳转到相应的标签处继续运行
  1. ::label_name::
  2. goto label_name
  3. 限制条件
    1. 标签可见规则
    2. goto不能跳转到局部变量的作用域，除非在代码块的最后一个有效语句之后

if 0 then
    print("0 为真")
end

if "" then  
    print("''为假")
end

-- 嵌套，switch代替方案1
local function ops(a, op, b)
    if op == "+" then
        return a+b
    elseif op == "-" then -- 注意写法
        return a-b
    elseif op == "*" then
        return a*b
    elseif op == "/" then
        return a/b
    else
        return nil
    end
end
print(ops(4,"+",2))

-- 嵌套，switch代替方案2
local tab = {}
tab["+"] = function(a,b)
    return a+b
end
tab["-"] = function(a,b)
    return a-b
end
tab["*"] = function(a,b)
    return a*b
end
tab["/"] = function(a,b)
    return a/b
end
local function ops_switch(a, op, b)
    if tab[op] then
        return tab[op](a, b)
    end
    return nil
end
print(ops_switch(4,"+",2))


-- 只要条件满足就一直反复执行，直到条件为假
while condition-expression do

end

local sum_tab = {1,2,3,4,5,6}
local index = 1
local sum = 0
while sum_tab[index] do
    sum = sum + sum_tab[index]
    index = index + 1
end
print("sum result = ", sum)


-- 一直反复执行，直到条件为真
repeat

until condition

local line 
local file, err = io.open("./2.txt", "r")
repeat 
    line = file:read()
until line ~= ""
print(line)

-- do end相当于{}
do
    local line
    local count = 0
    local file,err = io.open("./2.txt", "r")
    for line in file:lines()
        repeat 
            count = count + 1
            if line == "" then
                break -- 跳出repeat
            end
        until true
        if line ~= "" then 
            print(line)
            break
        end
    end
end

-- for 数值型
local sum_for = 0
for i = 1, #sum_tab do -- 起始，终止，步长，步长不写就是1
    sum_for = sum_for + sum_tab[i]
end
print("sum_for result：", sum_for)

sum_for = 0
for _,v in ipairs(sum_tab) do
    sum_for = sum_for + v
end
print("sum_for result：", sum_for)


-- goto
do
    local line
    local count = 0
    local file,err = io.open("./2.txt", "r")
    for line in file:lines()
        count = count + 1
        if line == "" then
            goto continue -- 利用goto跳转
        else
            print(line)
            break
        end
        -- local ok = false 
        ::continue::
        -- print(ok) -- 这里不能跳，因为ok没有初始化，这里会出错
    end
end

编译以及错误处理

编译

loadfile
1. 从文件中加载lua代码段
2. 编译代码而不运行代码
3. 如果正确，返回一个函数
4. 如果错误，返回nil和错误信息
load
1. 从字符串中加载代码段
2. 默认在全局环境中编译代码
dofile
1. 编译和运行两步合一

预编译

luac支持对代码进行预编译，输出一个能被虚拟机直接识别的二进制文件
预编译后的代码大小可能比源代码大，但是加载的更快

错误处理

返回错误码
调用error引发一个异常错误

local f, err = loadfile("./temp.lua")
if not f then
    print(err) -- 如果有编译错误，会在这里打印
else 
    print("compile success", f()) -- 这里才执行
end

-- load，与直接的函数调用的区别：load总是在全局代码段去编译代码，所以i就会是全局变量
i = 0
local f,err = load("i=i+1")
if not f then
    print(err)
else
    print(f())
end

-- 同时加载 + 编译 + 执行
local ok = dofile("./temp.lua")
print(ok)

-- 异常1
y = "hello"
res = math.sin(y) -- 会直接抛出异常
print(res) -- 不会被执行

-- 异常2
local f, err = io.open("./a.txt", "r") -- 当文件不存在的时候，返回err这个错误码
if not f then
    print("err happened:", err)
end


-- 自己实现一个接口，使用错误码处理1
local function sin(x)
    if not tonumber(x) then
        return nil, "cant convert number"
    end
    return math.sin(x)
end
print(sin("hello")) -- 不再会抛出异常

-- 自己实现一个接口，使用错误码处理2
local function sin2(x)
    local value, err = pcall(math.sin(x)) -- 安全调用
    return value, err
end
print(sin2("hello")) -- 不再会抛出异常

-- 自己实现一个接口，使用抛出异常处理
local function io_open(filename, mode)
    local f, err = io.open(filename, mode)
    if not f then 
        return error(err) -- 抛出异常，这个也可以从外面进行pcall
    end
end
io_open("./a.txt", "r")

模块和包

模块就是外部代码（lua或c），通过require加载，通常会返回一张表
require，模块名作为参数
1. 在表package.loaded中检查模块是否已经被加载
  1. 已加载直接返回
  2. 未加载，进行下一步
2. 通过加载器在指定路径搜索
  1. lua文件
    1. package.path可以指定路径
    2. loadfile
  2. c动态库
    1. package.cpath可以指定路径
    2. 底层函数是通过package.loadlib加载
    3. 会在动态库中查找luaopen_modname的函数，必须有这个函数
  3. 当前目录或系统目录
    1. ./
    2. /usr/local/lua/?.lua
    3. /usr/local/lib/?.so
  4. 如果加载失败，抛出异常
3. 将加载结果保存在package.loaded中，将来再次加载时直接返回
lua模块编写方法
1. local _M = {}
2. function _M.func1() … end
3. local function func2() … end
4. return _M

util.lua

local _M = {}

function _M.add(a,b)
    return a+b
end

return _M

test.lua

1 2	local util = require "util" print(util.add(1,2))

元表和元方法

元表

元表可以修改一个值在面对未知操作时的行为
table和userdata都具备独立的元表
只有table和可以在lua中修改设置元表
userdata只能在c中修改设置元表而不能在lua中设置（但是debug.setmetatable可以，但是线上代价很高，调试的时候可以用）
其他类型包括lightuserdata共享对应类型所属的同一个元表

元方法

算术运算相关元方法
关系运算相关元方法
库定义的元方法
表相关的元方法
1. _index元方法
  1. 当访问一个表不存在的字段会触发的元方法
2. _newindex元方法
  1. 当对一个表不存在的索引赋值时触发的元方法

example1 具有默认值的表

local tab = {x=1,y=2}
local function set_default(t, default)
    local mt = {__index = function() return default end}
    setmetatable(t, mt)
end
print(tab.x,tab.y,tab.z) -- z触发_index元方法,1,2,nil
set_default(tab, 0)
print(tab.x,tab.y,tab.z) -- z触发_index元方法,1,2,0

-- 优化写法
local mt = {__index = function(t) return t.___ end}
local function set_default_v2(t, default)
    t.___ = default
    setmetatable(t, mt)
end
set_default_v2(tab, 0) -- 这样元表只需要创建一次


local meta = {}
function meta.sum(t)
    local s = 0
    for _, v in ipairs(t) do
        s = s + v
    end
    return s
end
local _M = {}
function _M.new(t)
    setmetatable(t, nil)
    return setmetatable(t,{__index = meta})
end

return _M



local meta = require "meta"
local calc = meta.new({1,2,3,4})
print(calc.sum(calc))

example2 跟踪对表的访问

local function track(t)
    local proxy = {}
    local mt = {
        __index = function(_, k)
            print("getter element"..tostring(k))
            return t[k]
        end,
        __newindex = function(_, k, v)
            print("setter elements "..tostring(k).." to "..tostring(v))
            t[k] = v
        end,
        __pairs = function()
            return function(_, k)
                local next_k, next_v = next(t, k)
                if next_k ~= nil then
                    print("traversing element "..tostring(next_k))
                end
                return next_k, next_v
            end
        end,
        __len = function() return #t end
    }
    return setmetatable(proxy, mt)
end

local tab = {100,2000,"A",track}
local proxy = track(tab)
local temp = proxy[1]
proxy[2] = "hello"
for k,v in pairs(proxy) do

end

example3 只读的表

local function read_only(t)
    local proxy = {}
    local mt = {
        __index = t,
        __newindex = function(_,k,v)
            error("attempt to update a read_only table")
        end
    }
    return setmetatable(proxy, mt)
end
local days = read_only({"1","2","3","4","5","6","7"})
print(days[1])
days[2] = "xx" -- 直接异常

lua环境

帮助理解代码段、全局变量
全局环境
1. _G，存储在c的注册表当中
2. 代码段的外部局部变量_ENV

闭包

函数内部可以访问函数外部的变量
函数 + 上值（upvalue）

代码段 == 闭包

上值是_ENV

代码段的内容在匿名函数的内部

-- 逻辑演示，相当于lua看到的内容
local _ENV = _G
return function()
    -- 这里面就是一个单独的lua文件里写的内容
end

全局变量
1. 编译器在编译所有代码段前，在外层构建环境变量_ENV
2. 编译器将所有自由名称var变换为_ENV.var（就是没有被local或者函数内）
3. 函数load使用全局环境初始化代码段的第一个上值

-- 查看全局环境中的内容
for k,_ in pairs(_G) do
    print(k)
end

-- 如何通过修改_ENV的方式禁用功能
local print = print
local sin = math.sin

_ENV = {}
print(30)
print(sin(30))
print(math.cos(30)) -- 抛出异常

-- 因为lua中全局变量即使未声明去访问也不会报错，那当写错名字的时候会难以排查
-- 通过修改全局环境的元表，禁止访问或声明一个不存在的全局变量
setmetatable(_G,{
    __newindex = function(_,k,_)
        error("尝试写一个未声明的全局变量"..k, 2)
    end,
    __index = function(_,k)
        error("尝试访问一个未声明的全局变量"..k, 2)
    end
})
local function declare(name, init)
    rawset(_G, name, init or false) -- 绕开上面的元表，提供declare这个接口来声明全局变量
end

declare(hello, 1)

lua/C接口编程

概述

背景
1. lua是一种嵌入式语言，以库的形式提供，宿主应用链接lua库，将lua功能融入到其中
2. 可扩展，lua可以调用其他语言实现的函数
3. 应用形式：c->lua->c

basic.c

// gcc basic.c -o basic -llua -ldl -lm
#include <stdio.h>
#include <stdlib.h>
#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>

static void call_func_0(lua_State *L, const char* funcname)
{
    lua_getglobal(L, funcname);
    lua_call(L, 0, 0);
}

static void call_func_1(lua_State *L, const char* funcname, int params)
{
    lua_getglobal(L, funcname);
    lua_pushnumber(L, params); // 参数先压栈
    lua_call(L, 1, 0);
}

int main(int argc, char** argv)
{
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);

    if(argc > 1){
        if(luaL_dofile(L, argv[1]) != LUA_OK){
            const char* err = lua_tostring(L, -1);
            fprintf(stderr, "err:\t %s \n",err);
            return 1;
        }
        call_func_0(L, "Init");
        call_func_1(L, "loop", 1000);
        call_func_0(L, "DeInit");
    }
    lua_close(L);
    return 0;
}

basic.lua

function Init(...)
    print("init call",...)
end

function loop(...)
    print("loop call",...)
end

function DeInit(...)
    print("DeInit call",...)
end
-- 这个文件修改的时候，假设.c文件未修改，则不需要重新编译
print("hello lua c")

虚拟栈

lua和c之间通信都是通过虚拟栈实现
虚拟栈中存储的元素都是lua类型的值
lua调用c的函数每次调用新的虚拟栈
c调用lua，每个协程都有一个虚拟栈
c创建虚拟机时，伴随创建一个主协程，默认创建一个虚拟栈
考虑两个问题
1. 动态类型（lua）和静态类型（c）体系差异，会不有不匹配的情况
2. 自动内存管理（lua）和手动内存（c）管理之间不匹配
规律
1. lua_get*通常入栈
2. lua_push*通常入栈
3. lua_set*通常出栈
4. lua_to*栈上值的类型转换

闭包

C闭包

闭包：函数内部可以访问函数外部的变量
c闭包：一个c函数+若干个upvalue（上值）

uv.c

// gcc uv.c -o uv.so -fPIC --shared
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
#include <stdio.h>

static int 
lecho(lua_State *L){
    lua_Integer cnt = lua_tointeger(L, lua_upvalueindex(1)); // 取出上值

    const char * str = lua_tostring(L, -1);
    cnt++; 
    printf("[cnt=%lld] %s\n", cnt, str);
    lua_pushinteger(L, cnt); // 将上值重新压栈
    lua_replace(L, lua_upvalueindex(1)); // 将新的上值替换掉原来那个
    return 0;
}

int luaopen_uv(lua_State *L)
{
    lua_createtable(L, 0, 1); // 虚拟栈先入栈一个table，index为1
    lua_pushinteger(L, 0); // 再入栈一个整数0
    lua_pushcclosure(L, lecho, 1); // 在index为1的位置压入栈一个c函数（此时这个函数和整数0都在位置1处），那这个整数成为了lecho的上值
    lua_setfield(L, -2, "echo"); // 此时虚拟栈有两个元素，-2位置就是那个函数，取名叫echo
    return 1;
}

closure.lua

1
2
3

package.cpath = "./?.so;" .. package.cpath
local uv = require "uv"
uv.echo("hello")

userdata

指向一块内存的指针，该内存由lua来管理，是一个对象
lua_newuserdata*分配c对象内存（由lua来gc）
1. 内存大小必须固定，不能动态增加
2. 但是这块内存中的指针指向的数据（存放一个指针，指向的内容可以改变），可以动态增加（那么此时gc的是有一定要写一个元方法去触发释放指针指向的内容，不然会有内存泄漏）

userdata.c

// gcc userdata.c -o ud.so -fPIC --shared
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
#include <stdio.h>

/*
1. 打印功能
2. 记录打印次数
3. 提供一个接口，输出最近打印的10条记录
*/

struct log{
    int count;
};

static int lecho(lua_State* L)
{
    struct log *q = (struct log*)luaL_checkudata(L, 1, "ll.userdata.log"); // 检查一号位置也就是栈底是不是我们想要的userdata，是的话就得到一个这样的指针
    q->count++;
    const char *str = lua_tostring(L, -1); // 每次调用的时候，栈底是userdata，具体看lua中传入的，-1位置就是传入的打印内容
    printf("[cnt = %lld] %s\n", cnt, str);
    lua_getuservalue(L, 1); // 取出记录表，并压栈
    lua_pushvalue(L, 2); // 将2号位置的内容复制到栈顶
    lua_seti(L, 3, (q->count-1) % 10 + 1); // 此时记录表在3号位？？？
    return 0;
}
static int lhistory(lua_State* L)
{
    struct log *q = (struct log*)luaL_checkudata(L, 1, "ll.userdata.log"); // 检查一号位置也就是栈底是不是我们想要的userdata，是的话就得到一个这样的指针
    lua_getuservalue(L, 1); // 取出记录表，并压栈
    if(q->count <= 10){
        for(int i = q->count;i>=1;i--){
            lua_geti(L, -1, i);
            printf("history :: %s\n", lua_tostring(L, -1));
            lua_pop(L, 1); // 注意维护栈平衡
        }
    } else {
        for(int i = 0; i < 10 ; i++){
            int cnt = q->count - i;
            int idx = (cnt-1)%10 + 1;
            lua_geti(L, -1, idx);
            printf("history :: %s\n", lua_tostring(L, -1));
            lua_pop(L, 1); // 注意维护栈平衡
        }
    }
    return 0;
}

static int lnew(lua_State* L)
{
    struct log *q = (struct log*)lua_newuserdata(L, sizeof(struct log)); // 入虚拟栈，userdata
    q->count = 0;
    lua_createtable(L, 10, 0); // 入虚拟栈，一个记录表
    lua_setuservalue(L, -2); // -2位置的记录表出栈，绑定为userdata的value
    if(luaL_newmetatable(L, "ll.userdata.log")){ // 入虚拟栈，metatable，注意这里即使已经存在了，仍然会入这个栈
        luaL_Reg m[] = { 
            {"echo", lecho},
            {"history", lhistory},
            {NULL, NULL},
        };
        luaL_newlib(L, m); // 入虚拟栈，m
        lua_setfield(L, -2,"__index"); // m退栈，并设置为metatable（-2位置）的__index
    }
    lua_setmetatable(L, -2); // metatable退栈并设置为userdata的元表，即使已经设置过了，然后设置失败了，也需要再一次设置一些元表，因为每次new的都是不同的userdata对象
    return 1;
}

static const luaL_Reg l[] = {
    {"new", lnew},
    {NULL, NULL},
};

int luaopen_ud(lua_State* L){
    luaL_newlib(L, l); // 导出多个函数
    return 1;
}

userdata.lua

package.cpath = package.cpath .. ";./?.so;"
local uv = require "ud"
local log = ud.new()
log.echo(log, "hello") -- log:echo("hello") 语法糖
log:history()

lightuserdata

指向一块内存的指针，该内存由宿主c来管理，是一个值

注册表

只能被c代码访问的全局表，使用注册表保存多个模块间共享的数据
通过尾索引LUA_REGISTRYINDEX来索引，注意：注册表不在虚拟栈
注册表是一个普通的表，所有c模块共享的表，需要选择全局唯一的KEY

// gcc basic_reg.c -o basic -llua -ldl -lm -Wl,-E
// main 设置
lua_pushinteger(L, 0);
lua_setfield(L, LUA_REGISTRYINDEX, "llin.reg.counter"); // 不在虚拟栈中，需要通过索引来设置，设置全局唯一key

// 定义全局函数
int Counter(lua_State *L){
    lua_getfield(L, LUA_REGISTRYINDEX, "llin.reg.counter"); // 将全局唯一key的值压栈
    int n = lua_tointeger(L, -1);
    n++;
    lua_pushinteger(L, n);
    lua_setfield(L, LUA_REGISTRYINDEX, "llin.reg.counter"); // 设置回去
    lua_pop(L,1); // 栈平衡
    return n;
}

1 2	// 其余c文件引用外部函数 extern int Counter(lua_State *L);

package.cpath = package.cpath .. ";./?.so;"
local uv = require "uv"
local ud = require "ud"
-- ....

gcc closure_reg.c -0 uv.so -fPIC --shared
gcc userdata_reg.c -0 ud.so -fPIC --shared
gcc basic_reg.c -o basic -llua -ldl -lm -Wl,-E # 一定要指定-E参数给链接器，不然执行的时候两个so会发现找不到前面那些链接的动态库的符号信息
./basic ./basic_reg.lua

lightuserdata

// main 设置
int *pcnt = (int*)malloc(sizeof(int));
*pcnt = 0;
lua_pushlightuserdata(L, pcnt);
lua_setfield(L, LUA_REGISTRYINDEX, "llin.reg.counter"); // 不在虚拟栈中，需要通过索引来设置，设置全局唯一key
//....
free(pcnt); // 一定要c自己释放
pcnt = NULL;

// 定义全局函数
int Counter(lua_State *L){
    lua_getfield(L, LUA_REGISTRYINDEX, "llin.reg.counter"); // 将全局唯一key的值压栈
    int *pcnt = (int*)lua_touserdata(L,-1);
    int n = ++(*pcnt);
    lua_pop(L, 1);
    return n;
}

1 2	// 其余c文件引用外部函数 extern int Counter(lua_State *L);

package.cpath = package.cpath .. ";./?.so;"
local uv = require "uv"
local ud = require "ud"
-- ....

gcc closure_reg.c -0 uv.so -fPIC --shared
gcc userdata_reg.c -0 ud.so -fPIC --shared
gcc basic_reg.c -o basic -llua -ldl -lm -Wl,-E # 一定要指定-E参数给链接器，不然执行的时候两个so会发现找不到前面那些链接的动态库的符号信息
./basic ./basic_reg.lua

2024-06-14 该篇文章被 Cleofwine 归为分类: Game