C ++用可变参数调用lua函数

时间:2011-10-25 06:06:23

标签: c++ templates lua

好的,所以这可能不是最好的设计决定,我真的不想使用像LuaBind这样的东西......我只是好奇如果在C ++ 03中可以使用以下内容(C ++ 11使其成为可能)使用可变参数模板)。此外,我确信之前已经问过,但我找不到直接的答案!

假设我有一个帮助方法从代码中调用Lua函数:

void CallFunction(char* functionName, ...);

可能接受N个args(使用va_arg或多个args的任何其他方法)

如果可能的话,我怎样才能计算出每个参数的类型,并将其传递给相应的lua_push {type}();在调用所需的lua函数之前函数?

我不确定这是否可以用var_arg完成,因为你在获取参数时必须知道类型,我试图用void *抓住它并将其传递给专门的模板,但它试图通过它到模板。

希望在C ++上好得多的人会有一两招! 谢谢堆

1 个答案:

答案 0 :(得分:9)

我会考虑包装你在类中调用lua函数的功能。它有几个好处,我会在一秒钟内告诉你,但首先这里是一个可能的实现想法。请注意,我没有测试过这段代码(或者甚至尝试编译它),这只是我根据之前尝试做同样事情而从头脑中快速写的东西。

namespace detail
{
    // we overload push_value instead of specializing
    // because this way we can also push values that
    // are implicitly convertible to one of the types

    void push_value(lua_State *vm, lua_Integer n)
    {
        lua_pushinteger(vm, n);
    }

    void push_value(lua_State *vm, lua_Number n)
    {
        lua_pushnumber(vm, n);
    }

    void push_value(lua_State *vm, bool b)
    {
        lua_pushboolean(vm, b);
    }

    void push_value(lua_State *vm, const std::string& s)
    {
        lua_pushstring(vm, s.c_str());
    }

    // other overloads, for stuff like userdata or C functions

    // for extracting return values, we specialize a simple struct
    // as overloading on return type does not work, and we only need
    // to support a specific set of return types, as the return type
    // of a function is always specified explicitly

    template <typename T>
    struct value_extractor
    {
    };

    template <>
    struct value_extractor<lua_Integer>
    {
        static lua_Integer get(lua_State *vm)
        {
            lua_Integer val = lua_tointeger(vm, -1);
            lua_pop(vm, 1);
            return val;
        }
    };

    template <>
    struct value_extractor<lua_Number>
    {
        static lua_Number get(lua_State *vm)
        {
            lua_Number val = lua_tonumber(vm, -1);
            lua_pop(vm, 1);
            return val;
        }
    };

    template <>
    struct value_extractor<bool>
    {
        static bool get(lua_State *vm)
        {
            bool val = lua_toboolean(vm, -1);
            lua_pop(vm, 1);
            return val;
        }
    };

    template <>
    struct value_extractor<std::string>
    {
        static std::string get(lua_State *vm)
        {
            std::string val = lua_tostring(vm, -1);
            lua_pop(vm, 1);
            return val;
        }
    };

    // other specializations, for stuff like userdata or C functions
}

// the base function wrapper class
class lua_function_base
{
public:
    lua_function_base(lua_State *vm, const std::string& func)
        : m_vm(vm)
    {
        // get the function
        lua_getfield(m_vm, LUA_GLOBALSINDEX, func.c_str());
        // ensure it's a function
        if (!lua_isfunction(m_vm, -1)) {
            // throw an exception; you'd use your own exception class here
            // of course, but for sake of simplicity i use runtime_error
            lua_pop(m_vm, 1);
            throw std::runtime_error("not a valid function");
        }
        // store it in registry for later use
        m_func = luaL_ref(m_vm, LUA_REGISTRYINDEX);
    }

    lua_function_base(const lua_function_base& func)
        : m_vm(func.m_vm)
    {
        // copy the registry reference
        lua_rawgeti(m_vm, LUA_REGISTRYINDEX, func.m_func);
        m_func = luaL_ref(m_vm, LUA_REGISTRYINDEX);
    }

    ~lua_function_base()
    {
        // delete the reference from registry
        luaL_unref(m_vm, LUA_REGISTRYINDEX, m_func);
    }

    lua_function_base& operator=(const lua_function_base& func)
    {
        if (this != &func) {
            m_vm = func.m_vm;
            lua_rawgeti(m_vm, LUA_REGISTRYINDEX, func.m_func);
            m_func = luaL_ref(m_vm, LUA_REGISTRYINDEX);
        }
        return *this;
    }
private:
    // the virtual machine and the registry reference to the function
    lua_State *m_vm;
    int m_func;

    // call the function, throws an exception on error
    void call(int args, int results)
    {
        // call it with no return values
        int status = lua_pcall(m_vm, args, results, 0);
        if (status != 0) {
            // call failed; throw an exception
            std::string error = lua_tostring(m_vm, -1);
            lua_pop(m_vm, 1);
            // in reality you'd want to use your own exception class here
            throw std::runtime_error(error.c_str());
        }
    }
};

// the function wrapper class
template <typename Ret>
class lua_function : public lua_function_base
{
public:
    lua_function(lua_State *vm, const std::string& func)
        : lua_function_base(vm, func)
    {
    }

    Ret operator()()
    {
        // push the function from the registry
        lua_rawgeti(m_vm, LUA_REGISTRYINDEX, m_func);
        // call the function on top of the stack (throws exception on error)
        call(0);
        // return the value
        return detail::value_extractor<Ret>::get(m_vm);
    }

    template <typename T1>
    Ret operator()(const T1& p1)
    {
        lua_rawgeti(m_vm, LUA_REGISTRYINDEX, m_func);
        // push the argument and call with 1 arg
        detail::push_value(m_vm, p1);
        call(1);
        return detail::value_extractor<Ret>::get(m_vm);
    }

    template <typename T1, typename T2>
    Ret operator()(const T1& p1, const T2& p2)
    {
        lua_rawgeti(m_vm, LUA_REGISTRYINDEX, m_func);
        // push the arguments and call with 2 args
        detail::push_value(m_vm, p1);
        detail::push_value(m_vm, p2);
        call(2);
        return detail::value_extractor<Ret>::get(m_vm);
    }

    template <typename T1, typename T2, typename T3>
    Ret operator()(const T1& p1, const T2& p2, const T3& p3)
    {
        lua_rawgeti(m_vm, LUA_REGISTRYINDEX, m_func);
        detail::push_value(m_vm, p1);
        detail::push_value(m_vm, p2);
        detail::push_value(m_vm, p3);
        call(3);
        return detail::value_extractor<Ret>::get(m_vm);
    }

    // et cetera, provide as many overloads as you need
};

// we need to specialize the function for void return type
// as the other class would fail to compile with void as return type
template <>
class lua_function<void> : public lua_function_base
{
public:
    lua_function(lua_State *vm, const std::string& func)
        : lua_function_base(vm, func)
    {
    }

    void operator()()
    {
        lua_rawgeti(m_vm, LUA_REGISTRYINDEX, m_func);
        call(0);
    }

    template <typename T1>
    void operator()(const T1& p1)
    {
        lua_rawgeti(m_vm, LUA_REGISTRYINDEX, m_func);
        detail::push_value(m_vm, p1);
        call(1);
    }

    template <typename T1, typename T2>
    void operator()(const T1& p1, const T2& p2)
    {
        lua_rawgeti(m_vm, LUA_REGISTRYINDEX, m_func);
        detail::push_value(m_vm, p1);
        detail::push_value(m_vm, p2);
        call(2);
    }

    template <typename T1, typename T2, typename T3>
    void operator()(const T1& p1, const T2& p2, const T3& p3)
    {
        lua_rawgeti(m_vm, LUA_REGISTRYINDEX, m_func);
        detail::push_value(m_vm, p1);
        detail::push_value(m_vm, p2);
        detail::push_value(m_vm, p3);
        call(3);
    }

    // et cetera, provide as many overloads as you need
};

这里的想法是,在构造时,函数类将找到具有名称的函数并将其存储在注册表中。之所以我这样做,而不是仅存储函数名称并在每次调用时从全局索引中获取它,是因为这样,如果稍后的某个其他脚本将用另一个值替换全局名称(可能是函数对象仍然会引用正确的函数。

无论如何,你可能想知道为什么要经历这一切的麻烦。这种方法有很多好处:

您现在拥有一个用于处理lua函数对象的自包​​含类型。您可以轻松地在代码中传递它们,而不必担心lua堆栈或lua内部。以这种方式编写代码也更简洁,更不容易出错。

因为lua_function重载了op(),所以你基本上有一个函数对象。这样做的好处是能够将其用作接受它们的任何算法或函数的回调。例如,假设你有一个lua_function<int> foo("foo");,让我们说lua中的函数foo有两个参数,一个double和一个字符串。你现在可以这样做:

// or std::function if C++11
boost::function<int (double, std::string)> callback = foo;
// when you call the callback, it calls the lua function foo()
int result = callback(1.0, "hello world");

这是非常强大的机制,因为您现在可以将您的lua代码绑定到现有的C ++代码,而无需编写任何其他包装代码。

正如您所看到的,这也让您可以轻松地从lua函数中获取返回值。根据您之前的想法,您必须在调用CallFunction后从堆栈中手动提取值。这里明显的缺点是,这个类只支持一个返回值,但如果你需要更多,你可以很容易地扩展这个类的想法(即你可以让类采取额外的模板参数进行多次返回类型,或者你可以使用boost::any并返回它们的容器。)