如何获取从C ++发送到Lua函数的表的更新值? [英] How to get updated value of table sent from C++ to Lua function?
问题描述
我试图将浮点向量从C ++函数传递给Lua函数作为表参数，然后在Lua函数调用之后获取向量的更新值.
I'm trying to pass a float vector from C++ function to Lua function as a table parameter and then get the updated value of the vector after the Lua function call.
这是简单的示例代码.
void myFunc(lua_State *L, std::vector<float> &vec) {
lua_getglobal(L, "myFunc");
lua_newtable(L);
for (size_t i=0; i<vec.size(); ++i) {
lua_pushinteger(L, i+1);
lua_pushnumber(L, vec[i]);
lua_settable(L, -3);
}
if (lua_pcall(L, 1, 0, 0) != 0) {
std::cout << "Error : Failed to call myFunc" << std::endl;
}
}
然后我可以按以下方式调用此函数.
And then I can call this function as the following.
std::vector<float> vec = {1,2,3,4,5}; //an array that will be sent to Lua as table
myFunc(L, vec); //call "myFunc" function in Lua and pass the array as an argument
/* <Lua function which will be called>
function myFunc(t)
for i=1, #t do
t[i] = t[i] * 2
end
end
*/
//how to update elements of "vec" here so it now becomes {2,4,6,8,10}?
正如我在代码中评论的那样，我想在调用Lua函数之后更新vector<float> vec的元素.
As I commented in the code, I would like to update the elements of vector<float> vec after calling the Lua function.
是否可以将数组传递给Lua函数作为参考? (例如它在C ++函数中的工作方式)
Is it possible to pass the array to Lua function as a reference? (like how it works in C++ functions)
如果没有，是否可以获取Lua table(t)的值，以便在调用该函数后可以将它们写回到C ++中的float向量?
If not, is it possible to get the values of Lua table(t) so I can write them back to the float vector in C++ after calling the function?
谢谢！
推荐答案
将std :: vector与Lua表之间进行转换
如在聊天中讨论的那样，可能需要将函数参数从std::vector<float>转换为Lua表并返回从Lua表到std::vector<float>的值.这样做的好处是它在Lua端是完全透明的.
Converting std::vector to and from Lua table
As discussed in chat it might be desirable to convert the function arguments from std::vector<float> to Lua tables and the return value from Lua table to std::vector<float>. The advantage of this is that it is completely transparent at the Lua end.
函数as_table通过一对迭代器创建一个新表，from_table从堆栈顶部的Lua表转换为一对迭代器.
The function as_table creates a new table from a pair of iterators, from_table converts from a Lua table on top of the stack to a pair of iterators.
#include <algorithm>
#include <cassert>
#include <iostream>
#include <vector>
#include <lua.hpp>
template <typename T, typename U>
void as_table(lua_State* L, T begin, U end) {
lua_newtable(L);
for (size_t i = 0; begin != end; ++begin, ++i) {
lua_pushinteger(L, i + 1);
lua_pushnumber(L, *begin);
lua_settable(L, -3);
}
}
template <typename T, typename U>
void from_table(lua_State* L, T begin, U end) {
assert(lua_istable(L,-1));
for (size_t i = 0; begin != end; ++begin, ++i) {
lua_pushinteger(L, i + 1);
lua_gettable(L, -2);
*begin = lua_tonumber(L, -1);
lua_pop(L, 1);
}
}
int main(int argc, char *argv[]) {
if (argc != 2) {
std::cerr << "Usage: " << argv[0] << " <script.lua>\n";
return 1;
}
lua_State *L = luaL_newstate();
luaL_openlibs(L);
if (luaL_dofile(L, argv[1]) != 0) {
std::cerr << "lua_dofile failed: " << lua_tostring(L, -1) << '\n';
lua_close(L);
return 1;
}
lua_getglobal(L, "perform");
std::vector<float> iv(2000, 1);
std::vector<float> ov(2000, 2);
as_table(L, iv.begin(), iv.end());
as_table(L, ov.begin(), ov.end());
if (lua_pcall(L, 2, 1, 0) != 0) {
std::cerr << "lua_pcall failed: " << lua_tostring(L, -1)
<< '\n';
lua_close(L);
return 1;
}
std::vector<float> w(2000);
from_table(L, w.begin(), w.end());
assert(std::all_of(w.begin(), w.end(),
[](float p) { return p == 3.0f; }));
}
这是上面的测试用例使用的小Lua脚本.
Here is the little Lua script which is to be used with the testcase above.
function perform(v1,v2)
local n = math.min(#v1,#v2)
local v = {}
for i = 1,n do
v[i] = v1[i] + v2[i]
end
return v
end
std :: vector作为用户数据
如果大多数数据操作是在Lua端完成的，则将向量作为表推送是有利的，因为Lua表实际上非常快.但是，如果大多数计算是在C ++端完成的，而Lua端只会在C ++实现的函数之间传递数据，则这种方法会增加大量开销，因为我们将花费大量时间来回转换Lua表和std::vector.为此，Lua提供了 userdata ，一种包装C/C ++数据结构的方法，使它们看起来像是本机Lua数据类型.缺点是，当提供函数来检查来自Lua的用户数据时，它们通常很慢，因为必须重复检查参数并且必须调用多个嵌套函数.将其与元表结合使用，可以获得用于数组访问和长度操作的语法糖，您会发现自己陷入了性能困境.
std::vector as userdata
Pushing the vector as a table is advantageous if most of the data manipulation is done on the Lua end, because Lua tables are actually pretty fast. If, however, most of the computations were done on the C++ end and the Lua end would only pass around the data between functions implemented in C++ this approach would add a large overhead, because we'd spend lots of time converting back and forth between Lua tables and std::vector. To this end, Lua provides userdata, a method to wrap C/C++ datastructures in such a way that they apprear as native Lua datatypes. The downside is, that when offering functions to inspect userdata from Lua, those are usually slow, because arguments have to be checked repeatedly and multiple nested functions have to be called. Combine this with metatables to have syntactic sugar for array access and length operations and you will find yourself in performance hell.
也就是说，我构建了一个将向量作为用户数据推送并设置其元表的示例. 《 Lua编程》一书中的 28.1 – Userdata 一章中也描述了此过程. "(读！).
That said, I have constructed an example of pushing the vector as userdata and set its metatable. This process is also described in the chapter 28.1 – Userdata in the book "Programming in Lua" (read it!).
#include <iostream>
#include <vector>
#include <lua.hpp>
std::vector<float>& checkvector(lua_State *L, int index) {
std::vector<float> *v = *static_cast<std::vector<float> **>(
luaL_checkudata(L, index, "std::vector<float>"));
luaL_argcheck(L, v != nullptr, index, "invalid pointer");
return *v;
}
static int newvector(lua_State *L) {
size_t size = luaL_checkinteger(L, 1);
luaL_argcheck(L, size >= 0, 1, "invalid size");
*static_cast<std::vector<float> **>(lua_newuserdata(
L, sizeof(std::vector<float> *))) = new std::vector<float>(size);
luaL_getmetatable(L, "std::vector<float>");
lua_setmetatable(L, -2);
return 1;
}
void pushvector(lua_State *L, std::vector<float> const &v) {
std::vector<float> *udata = new std::vector<float>();
*udata = v;
*static_cast<std::vector<float> **>(lua_newuserdata(
L, sizeof(std::vector<float> *))) = udata;
luaL_getmetatable(L, "std::vector<float>");
lua_setmetatable(L, -2);
}
static int deletevector(lua_State *L) {
delete &checkvector(L, 1);
return 0;
}
static int setvector(lua_State *L) {
std::vector<float> &v = checkvector(L, 1);
size_t index = luaL_checkinteger(L, 2) - 1;
luaL_argcheck(L, index < v.size(), 2, "index out of range");
luaL_argcheck(L, lua_isnumber(L, 3), 3, "not a number");
float record = lua_tonumber(L, 3);
v.at(index) = record;
return 0;
}
static int getvector(lua_State *L) {
std::vector<float> &v = checkvector(L, 1);
size_t index = luaL_checkinteger(L, 2) - 1;
luaL_argcheck(L, index < v.size(), 2, "index out of range");
lua_pushnumber(L, v.at(index));
return 1;
}
static int getsize(lua_State *L) {
std::vector<float> &v = checkvector(L, 1);
lua_pushinteger(L, v.size());
return 1;
}
static int vectortostring(lua_State *L) {
std::vector<float> &v = checkvector(L, 1);
lua_pushfstring(L, "std::vector<float>(%d)", v.size());
return 1;
}
static const struct luaL_Reg vector_float_lib[] = {
{"new", newvector},
{nullptr, nullptr} // sentinel
};
static const struct luaL_Reg vector_float_meta[] = {
{"__tostring", vectortostring},
{"__newindex", setvector},
{"__index", getvector},
{"__len", getsize},
{"__gc", deletevector},
{nullptr, nullptr} // sentinel
};
int luaopen_vector_float(lua_State *L) {
luaL_newmetatable(L, "std::vector<float>");
luaL_setfuncs(L, vector_float_meta, 0);
luaL_newlib(L, vector_float_lib);
return 1;
}
static int send_vector(lua_State *L) {
std::vector<float> v = { 1, 2, 3, 4 };
pushvector(L,v);
return 1;
}
static int retrieve_vector(lua_State *L) {
std::vector<float> &v = checkvector(L, 1);
for (auto const &p : v) {
std::cout << p << '\n';
}
return 0;
}
int main(int argc, char *argv[]) {
lua_State *L = luaL_newstate();
luaL_openlibs(L);
luaL_requiref(L, "vector", luaopen_vector_float, 1);
lua_pop(L, 1);
lua_pushcfunction(L,send_vector);
lua_setglobal(L,"send_vector");
lua_pushcfunction(L,retrieve_vector);
lua_setglobal(L,"retrieve_vector");
if (argc != 2) {
std::cerr << "Usage: " << argv[0] << " <script.lua>\n";
return 1;
}
luaL_dofile(L, argv[1]);
lua_close(L);
}
这可以执行以下Lua脚本
This can execute the following Lua script
local v = send_vector()
for i = 1,#v do
v[i] = 2*v[i]
end
retrieve_vector(v)
给出一个全局函数transform_vector，例如
Given a global function transform_vector, e.g.
function transform_vector(v)
for i = 1,#v do
v[i] = 2*v[i]
end
return v
end
可以使用向量参数调用此函数，并像使用其他任何Lua函数一样检索向量结果.
one can call this function with a vector argument and retrieve a vector result just like with any other Lua function.
std::vector<float> v = { 1, 2, 3, 4 };
lua_getglobal(L,"transform_vector");
pushvector(L,v);
if (lua_pcall(L,1,1,0) != 0) {
// handle error
}
std::vector<float> w = checkvector(L, -1);
这篇关于如何获取从C ++发送到Lua函数的表的更新值?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
