Lua元表__newindex处理结构体数组遇参数错误，求解决方案

错误根源 #

你遇到的数组操作报错，核心原因是对Lua索引操作的逻辑理解有误：当执行ms.option[o] = 1时，Lua会分两步执行：

1. 先调用ms.option，触发mystruct元表的__index，此时仅传递两个参数（mystruct的userdata和字段名"option"）；
2. 对第一步返回的结果执行[o] = 1，触发该结果元表的__newindex。

你的原代码错误地在mystruct的__index中尝试读取第三个参数（数组索引），导致Lua抛出参数缺失的错误。

正确实现思路 #

针对结构体中的数组（简单数组/结构体数组），需要为每个数组类型创建代理对象，通过代理对象的元表处理数组的索引读写操作。具体步骤如下：

1. 定义各类代理的元表与处理函数 #

首先为简单数组（option）、结构体数组（pf）、结构体内部数组（type_info）分别创建元表，并实现对应的__index和__newindex函数。

简单数组（option）的代理处理

// option数组的__index：读取数组元素
int option_array_index(lua_State *L) {
    int *arr = (int*)lua_touserdata(L, 1);
    int idx = lua_tointeger(L, 2);
    if (idx >= 0 && idx < 20) {
        lua_pushinteger(L, arr[idx]);
    } else {
        lua_pushnil(L);
    }
    return 1;
}

// option数组的__newindex：写入数组元素
int option_array_newindex(lua_State *L) {
    int *arr = (int*)lua_touserdata(L, 1);
    int idx = lua_tointeger(L, 2);
    int val = lua_tointeger(L, 3);
    if (idx >= 0 && idx < 20) {
        arr[idx] = val;
    }
    return 0;
}

结构体数组（pf）的代理处理

// pf数组的__index：返回对应位置的pinfo代理
int pf_array_index(lua_State *L) {
    struct pinfo *pf_arr = (struct pinfo*)lua_touserdata(L, 1);
    int idx = lua_tointeger(L, 2);
    if (idx >= 0 && idx < 5) {
        lua_pushlightuserdata(L, &pf_arr[idx]);
        luaL_getmetatable(L, "pinfo");
        lua_setmetatable(L, -2);
    } else {
        lua_pushnil(L);
    }
    return 1;
}

// pf数组的__newindex：禁止直接替换结构体数组元素（可选）
int pf_array_newindex(lua_State *L) {
    luaL_error(L, "Cannot assign to pf array elements directly");
    return 0;
}

pinfo结构体及其内部数组（type_info）的处理

// pinfo的__index：处理结构体成员与内部数组
int pinfo_index(lua_State *L) {
    struct pinfo *pi = (struct pinfo*)lua_touserdata(L, 1);
    const char *field = lua_tostring(L, 2);

    if (strcmp(field, "time") == 0) {
        lua_pushinteger(L, pi->time);
    } else if (strcmp(field, "hide_name") == 0) {
        lua_pushboolean(L, pi->hide_name);
    } else if (strcmp(field, "type_info") == 0) {
        lua_pushlightuserdata(L, pi->type_info);
        luaL_getmetatable(L, "pinfo_type_info_array");
        lua_setmetatable(L, -2);
    } else {
        lua_pushnil(L);
    }
    return 1;
}

// pinfo的__newindex：处理结构体成员赋值
int pinfo_newindex(lua_State *L) {
    struct pinfo *pi = (struct pinfo*)lua_touserdata(L, 1);
    const char *field = lua_tostring(L, 2);

    if (strcmp(field, "time") == 0) {
        pi->time = lua_tointeger(L, 3);
    } else if (strcmp(field, "hide_name") == 0) {
        pi->hide_name = lua_toboolean(L, 3);
    } else {
        luaL_error(L, "Unknown field %s for pinfo", field);
    }
    return 0;
}

// type_info数组的__index
int type_info_array_index(lua_State *L) {
    int *arr = (int*)lua_touserdata(L, 1);
    int idx = lua_tointeger(L, 2);
    if (idx >= 0 && idx < 10) {
        lua_pushinteger(L, arr[idx]);
    } else {
        lua_pushnil(L);
    }
    return 1;
}

// type_info数组的__newindex
int type_info_array_newindex(lua_State *L) {
    int *arr = (int*)lua_touserdata(L, 1);
    int idx = lua_tointeger(L, 2);
    int val = lua_tointeger(L, 3);
    if (idx >= 0 && idx < 10) {
        arr[idx] = val;
    }
    return 0;
}

2. 修改mystruct的元表与创建函数 #

更新mystruct的__index函数，返回对应数组的代理对象；同时在mystruct_create中注册所有代理元表：

// 更新mystruct的__index
int mystruct_index(lua_State *L) {
    struct mystruct *ms = (struct mystruct*)lua_touserdata(L, 1);
    const char *field = lua_tostring(L, 2);

    if (strcmp(field, "id") == 0) {
        lua_pushinteger(L, ms->id);
    } else if (strcmp(field, "value") == 0) {
        lua_pushinteger(L, ms->value);
    } else if (strcmp(field, "option") == 0) {
        lua_pushlightuserdata(L, ms->option);
        luaL_getmetatable(L, "mystruct_option_array");
        lua_setmetatable(L, -2);
    } else if (strcmp(field, "pf") == 0) {
        lua_pushlightuserdata(L, ms->pf);
        luaL_getmetatable(L, "mystruct_pf_array");
        lua_setmetatable(L, -2);
    } else {
        lua_pushnil(L);
    }
    return 1;
}

// 简化mystruct的__newindex（仅处理简单成员）
int mystruct_newindex(lua_State  *L) {
    struct mystruct *ms = (struct mystruct*)lua_touserdata(L, 1);
    const char *field = lua_tostring(L, 2);
    int value = (int)lua_tointeger(L, 3);

    if (strcmp(field, "id") == 0) {
        ms->id = value;
    } else if (strcmp(field, "value") == 0) {
        ms->value = value;
    } else {
        luaL_error(L, "Unknown field %s for mystruct", field);
    }
    return 0;
}

// 注册所有元表与全局函数
void mystruct_create(lua_State *L) {
    // 注册mystruct元表
    luaL_Reg mystructData[] = {
        { "__index", mystruct_index},
        { "__newindex", mystruct_newindex},
        {NULL, NULL}
    };
    luaL_newmetatable(L, "mystruct");
    luaL_setfuncs(L, mystructData, 0);
    lua_pop(L, 1);

    // 注册option数组元表
    luaL_Reg optionArrayData[] = {
        { "__index", option_array_index},
        { "__newindex", option_array_newindex},
        {NULL, NULL}
    };
    luaL_newmetatable(L, "mystruct_option_array");
    luaL_setfuncs(L, optionArrayData, 0);
    lua_pop(L, 1);

    // 注册pinfo元表
    luaL_Reg pinfoData[] = {
        { "__index", pinfo_index},
        { "__newindex", pinfo_newindex},
        {NULL, NULL}
    };
    luaL_newmetatable(L, "pinfo");
    luaL_setfuncs(L, pinfoData, 0);
    lua_pop(L, 1);

    // 注册pf数组元表
    luaL_Reg pfArrayData[] = {
        { "__index", pf_array_index},
        { "__newindex", pf_array_newindex},
        {NULL, NULL}
    };
    luaL_newmetatable(L, "mystruct_pf_array");
    luaL_setfuncs(L, pfArrayData, 0);
    lua_pop(L, 1);

    // 注册type_info数组元表
    luaL_Reg typeInfoArrayData[] = {
        { "__index", type_info_array_index},
        { "__newindex", type_info_array_newindex},
        {NULL, NULL}
    };
    luaL_newmetatable(L, "pinfo_type_info_array");
    luaL_setfuncs(L, typeInfoArrayData, 0);
    lua_pop(L, 1);

    // 设置全局MyStructLua对象
    lua_createtable(L, 0, 1);
    lua_pushcfunction(L, Get_mystruct);
    lua_setfield(L, -2, "GetMyStruct");
    lua_setglobal(L, "MyStructLua");
}

3. Lua端正常使用示例 #

local ms = MyStructLua.GetMyStruct(my_ptr)

-- 操作简单成员
ms.id = 1000
print(ms.id) -- 输出1000

-- 操作option数组
for o = 0, 19 do
    ms.option[o] = o + 1
end
print(ms.option[5]) -- 输出6

-- 操作pf结构体数组及其内部成员
ms.pf[0].time = 123
ms.pf[0].hide_name = true
ms.pf[0].type_info[3] = 456
print(ms.pf[0].time, ms.pf[0].type_info[3]) -- 输出123 456

内容的提问来源于stack exchange，提问作者Michael