将递归结构作为Lua表公开 由于历史原因，我在C++中构造了一个结构，它模拟了一个LUA表。 typedef union Value Value; typedef struct LuaTable LuaTable; typedef struct TableValue TableValue; enum ValueType { INT = 0, BOOL = 1, FLOAT = 2, STRING = 3, TABLE = 4, }; struct LuaTable { std::vector<TableValue> array; std::map<std::string, TableValue> hashmap; }; union Value { int c_int; bool c_bool; double c_float; std::string c_str; LuaTable table; }; struct TableValue { ValueType type; Value val; };

是一个代理

LuaTable l_tbl {...};
...
l_tbl['a']['b']['c']

在我开始考虑惰性评估（在某些元表中建立前缀）之前，我通常想知道我是否以正确的方式考虑这个问题

---

最简单的方法是通过解析

LuaTable

结构来初始化

c\u tbl

。这就是我被困的地方。有没有一种简单的方法可以解析这样的递归结构？我愿意重新设计它，以减轻解析/遍历困难。

如果您同意使用Lua C API而不是FFI，那么类似的方法也可以：

#包括
#包括
#包括
#包括
类型定义结构LuaTable LuaTable；
typedef结构TableValue TableValue；
结构逻辑表{
std：：矢量阵列；
std：：map hashmap；
};
结构表值{
枚举{
INT=0，
BOOL=1，
浮动=2，
字符串=3，
表=4，
}类型；
联合{
int c_int；
bool c_bool；
双c_浮球；
std：：字符串c_str；
可升降台；
};
TableValue（inti）：类型（int），c_int（i）{
TableValue（bool-b）：类型（bool），c_-bool（b）{}
TableValue（双d）：类型（FLOAT），c_FLOAT（d）{
TableValue（constchar*c）：类型（字符串），c_str（c）{}
TableValue（const std:：string&s）：类型（string），c_str（s）{}
TableValue（std:：string&&s）：类型（string），c_str（s）{}
TableValue（constluatable&t）：类型（TABLE），表（t）{}
TableValue（LuaTable&&t）：类型（TABLE），表（t）{}
TableValue（const TableValue&other）：类型（other.type）{
开关（类型）{
案例INT：
c_int=other.c_int；
打破
案例布尔：
c_bool=其他c_bool；
打破
案例浮动：
c_浮动=其他c_浮动；
打破
大小写字符串：
新建（&c_str）std:：string（其他.c_str）；
打破
案例表：
新（表和表）LuaTable（其他表）；
}
}
//TODO写入赋值运算符和移动构造函数
~TableValue（）{
开关（类型）{
大小写字符串：
{
使用std:：string；
c_str.~string（）；
}
打破
案例表：
表~LuaTable（）；
}
}
};
静态无效q64936405_推送（lua_状态*L，常数表值*v）{
如果（！v）{
卢阿努普什尼勒（L）；
返回；
}
开关（v->类型）{
案例表值：：INT:
lua_pushinteger（L，v->c_int）；
打破
案例表值：：BOOL:
lua_pushboolean（L，v->c_bool）；
打破
case TableValue:：FLOAT：
lua_pushnumber（L，v->c_float）；
打破
case TableValue:：字符串：
lua_pushlstring（L，v->c_str.c_str（），v->c_str.length（））；
打破
案例TableValue:：表：
//toDo考虑在某个地方创建一个弱表来保存这些表，因此多次检索相同的子表不会重复复制用户数据。
//并且让他们像在真实的桌子上一样进行平等的比较
const LuaTable**t=静态（lua_newuserdata（L，sizeof*t））；
*t=&v->table；
lua_getfield（L，lua_REGISTRYINDEX，“q64936405”）；
lua_可设置元表（L，-2）；
打破
}
}
静态int q64936405_索引（lua_状态*L）{
常量LuaTable*t=*静态（luaL_checkudata（L，1，“q64936405”）；
if（lua_isnumber（L，2））{
lua_整数k=lua_-tointeger（L，2）；
如果（k>=1&&k array.size（））{
q64936405_-push（L，&t->数组[k-1]）；
}否则{
卢阿努普什尼勒（L）；
}
}否则{
尺寸透镜；
const char*rawk=luaL_checklstring（L、2和len）；
const TableValue*v；
{//此块通过跳过迭代器的销毁来确保Lua错误不会导致UB
autoit=t->hashmap.find（std:：string{rawk，len}）；
if（it==t->hashmap.end（））{
v=零PTR；
}否则{
v=&it->second；
}
}
q64936405_推压（L，v）；
}
返回1；
}
静态输入q64936405_len（lua_State*L）{
常量LuaTable*t=*静态（luaL_checkudata（L，1，“q64936405”）；
lua_pushinteger（L，t->array.size（））；
返回1；
}
//重要的是，一旦将其传递给Lua，它在Lua_状态关闭之前是不可变的
//否则坏事就会发生
静态常量可用于\u结构{
{
42,
是的，
0.5,
“福”，
LuaTable{
{
“嵌套”
}, {
{“foo”，“bar”}
}
}
}, {
{“一”，1}，
{“两个”，2}
}
};
外部“C”
国际luaopen_q64936405（lua_州*L）{
const LuaTable**v=静态（lua_newuserdata（L，sizeof*v））；
*v=&u结构；
luaL_新元表（L，“q64936405”）；
lua_pushc函数（L，q64936405_索引）；
lua_设置域（L，-2，“_索引”）；
lua_pushc函数（L，q64936405_len）；
lua_设置域（L，-2，“_len”）；
lua_可设置元表（L，-2）；
//TODO写入对和IPAIR
返回1；
}

我将您的

ValueType

和

Value

滚动到

TableValue

中，但保留了您想要的结构

用以下方法进行测试：

local q64936405 = require('q64936405')
print(q64936405[1])
print(q64936405[2])
print(q64936405[3])
print(q64936405[4])
print(q64936405[5][1])
print(q64936405[5].foo)
print(q64936405.one)
print(q64936405.two)
print(#q64936405)

结果是：

42
真的
0.5
福
嵌套
酒吧
1.
2.
5.

如果您同意使用Lua C API而不是FFI，那么类似的方法也可以：

#包括
#包括
#包括
#包括
类型定义结构LuaTable LuaTable；
typedef结构TableValue TableValue；
结构逻辑表{
std：：矢量阵列；
std：：map hashmap；
};
结构表值{
枚举{
INT=0，
BOOL=1，
浮动=2，
字符串=3，
表=4，
}类型；
联合{
int c_int；
bool c_bool；
双c_浮球；
std：：字符串c_str；
可升降台；
};
TableValue（inti）：类型（int），c_int（i）{
TableValue（bool-b）：类型（bool），c_-bool（b）{}
TableValue（双d）：类型（FLOAT），c_FLOAT（d）{
TableValue（constchar*c）：类型（字符串），c_str（c）{}
TableValue（const std:：string&s）：类型（string），c_str（s）{}
TableValue（标准：：字符串
local q64936405 = require('q64936405')
print(q64936405[1])
print(q64936405[2])
print(q64936405[3])
print(q64936405[4])
print(q64936405[5][1])
print(q64936405[5].foo)
print(q64936405.one)
print(q64936405.two)
print(#q64936405)