在C中存储对lua函数的引用

问题描述 投票：0回答：3

我有一个用 C++ 实现的基本事件处理程序。 我的应用程序中还有一个嵌入式 Lua 解释器，我需要它与事件管理器交互。 最终目标是能够拥有一个事件处理程序，在事件触发时同时执行 C++ 和 Lua 函数。

我的问题是我无法想出一种简单的方法来存储对 C++ 代码中 lua 函数的引用。 我知道如何从 c 执行 Lua 函数（使用 

lua_getglobal
和 
lua_pcall
），但我更喜欢存储对函数本身的引用，这样我就可以将 Lua 函数直接传递给 
registerListener

注意 假设所有 Lua 监听器的用户数据都是 

NULL
是可以接受的。

这是我的代码：

EventManager.h

#include <string>
#include <map>
#include <vector>

using namespace std;

typedef void (*fptr)(const void* userdata, va_list args);
typedef pair<fptr, void*> Listener;
typedef map<string, vector<Listener> > CallbackMap;

class EventManager {
private:
    friend ostream& operator<<(ostream& out, const EventManager& r);

    CallbackMap callbacks;
    static EventManager* emInstance;
    EventManager() {
        callbacks = CallbackMap();
    }
    ~EventManager() {
    }
public:
    static EventManager* Instance();
    bool RegisterEvent(string const& name);
    void RegisterListener(string const &event_name, fptr callback,
            void* userdata);
    bool FireEvent(string name, ...);
};

inline ostream& operator<<(ostream& out, const EventManager& em) {
    return out << "EventManager: " << em.callbacks.size() << " registered event"
            << (em.callbacks.size() == 1 ? "" : "s");
}

事件管理器.cpp

#include <cstdarg>
#include <iostream>
#include <string>

#include "EventManager.h"

using namespace std;

EventManager* EventManager::emInstance = NULL;

EventManager* EventManager::Instance() {
    if (!emInstance) {
        emInstance = new EventManager;
    }

    return emInstance;
}

bool EventManager::RegisterEvent(string const& name) {
    if (!callbacks.count(name)) {
        callbacks[name] = vector<Listener>();
        return true;
    }

    return false;
}

void EventManager::RegisterListener(string const &event_name, fptr callback,
        void* userdata) {
    RegisterEvent(event_name);
    callbacks[event_name].push_back(Listener(callback, userdata));
}

bool EventManager::FireEvent(string name, ...) {
    map<string, vector<Listener> >::iterator event_callbacks =
            callbacks.find(name);
    if (event_callbacks == callbacks.end()) {
        return false;
    }

    for (vector<Listener>::iterator cb =
            event_callbacks->second.begin();
            cb != event_callbacks->second.end(); ++cb) {
        va_list args;
        va_start(args, NULL);
        (*cb->first)(cb->second, args);
        va_end(args);
    }

    return true;
}

luaw_eventmanager.h

#pragma once
#ifndef LUAW_EVENT_H
#define LUAW_EVENT_H

#include "EventManager.h"

extern "C" {

#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>

void luaw_eventmanager_push(lua_State* L, EventManager* em);
int luaopen_weventmanager(lua_State* L);

}
#endif

luaw_eventmanager.cpp

#include <assert.h>
#include <stdio.h>

#include <sstream>
#include <iostream>

#include "luaw_eventmanager.h"

using namespace std;

static int
luaw_eventmanager_registerevent(lua_State* L)
{
    int nargs = lua_gettop(L);
    if (nargs != 2) {
        return 0;
    }

    stringstream ss;
    ss << luaL_checkstring(L, 2);

    EventManager::Instance()->RegisterEvent(ss.str());
    return 1;
}

static int
luaw_eventmanager_registerlistener(lua_State* L)
{
    return 1;
}

static int
luaw_eventmanager_fireevent(lua_State* L)
{
    return 1;
}

static int
luaw_eventmanager_tostring(lua_State* L)
{
    stringstream ss;
    ss << *EventManager::Instance();
    lua_pushstring(L, &ss.str()[0]);
    return 1;
}

static const struct luaL_Reg luaw_eventmanager_m [] = {
    {"registerEvent", luaw_eventmanager_registerevent},
    {"registerListener", luaw_eventmanager_registerlistener},
    {"fireEvent", luaw_eventmanager_fireevent},
    {"__tostring", luaw_eventmanager_tostring},
    {NULL, NULL}
};

void 
luaw_eventmanager_push(lua_State* L, EventManager* em)
{
    EventManager** emUserdata = (EventManager**)lua_newuserdata(L, sizeof(EventManager*));
    *emUserdata = em;
    luaL_getmetatable(L, "WEAVE.mEventManager");
    lua_setmetatable(L, -2);
}

int 
luaopen_weventmanager(lua_State* L)
{
    luaL_newmetatable(L, "WEAVE.mEventManager");
    lua_pushvalue(L, -1);
    lua_setfield(L, -2, "__index");
    luaL_register(L, NULL, luaw_eventmanager_m);
    assert(!lua_isnil(L, -1));
    return 1;
}
c++ event-handling lua
3个回答
17
投票

所有 Lua 拥有的对象都会被垃圾收集。这包括函数。因此，即使你可以获得对 Lua 函数的引用，Lua 仍然会拥有它，因此每当 Lua 检测到它不再被引用时，它就会受到 GC 的影响。

外部代码不能拥有 Lua 引用。但是外部代码可以将引用存储在 Lua 代码无法到达（因此无法破坏）的地方：Lua 注册表。 Lua注册表

是一个Lua表（位于堆栈伪索引

LUA_REGISTRYINDEX，因此可以从堆栈访问），Lua代码无法（直接）访问。因此，它是您存储所需物品的安全场所。由于它是一个 Lua 表，因此您可以像任何其他 Lua 表一样操作它（添加值、键等）。 

但是，注册表是全局的，如果您使用其他 C 模块，它们完全有可能开始破坏彼此的东西。因此，最好为每个模块选择一个特定的注册表项并在该注册表项中构建一个表。

第一步：

初始化 C 接口代码时，创建一个表并将其粘贴到注册表中的已知键中。只有一张空桌子。

当 Lua 代码向您传递一个 Lua 函数用作回调时，从特殊键加载该表并将 Lua 函数粘贴在那里。当然，要做到这一点，您需要为每个注册的函数提供一个唯一的密钥（您将其存储为 Lua 函数的 void*

数据），稍后您可以使用它来检索该函数。

Lua 有一个简单的机制可以做到这一点：

luaL_ref

。该函数将使用给定的表将对象注册到堆栈顶部。此注册过程保证为每个注册对象返回唯一的整数键（只要您不“手动”修改系统背后的表）。 

luaL_unref
发布参考，allo 由于引用是整数键，因此您可以
只需从
int

到

void* 进行转换，然后将其作为数据。我可能会使用一个显式对象（malloc

ing an
int
），但你可以按照你喜欢的方式存储它。
第二步：
注册 Lua 函数时，使用 
luaL_ref
 将其添加到步骤 1 中创建的注册表中。将此函数返回的密钥存储在已注册函数的 
void* 参数中。


第三步：
 当需要调用该函数时，使用您存储在 
void*
 参数中的整数键来访问在步骤 1 中创建的注册表。这将为您提供该函数，然后您可以使用常用的 Lua 方法。


第四步：
当你注销Lua函数时，使用
luaL_unref
释放该函数（这样可以避免泄漏Lua内存）。如果您
malloc使用内存来存储整数密钥，请free
在此处。

    


我建议将您的函数存储到
注册表
中，并使用函数

    

    
    
    

    

        

            

                

                    
7
投票

                    

                

            

        

        
和
luaL_unref提供的参考机制。


这些函数使用 C 
int
 值来访问这些值。例如，在 C++ 类成员中存储这样的整数值很容易。 

    




@Nicolas Bolas 提供了很好的说明，但对于新手（包括我自己）来说太模糊了。
通过反复试验，我想出了可行的示例：


存储

    

    
    
    

    

        

            

                

                    
6
投票

                    
                

            

        

        
// create table for functions on top of the stack
lua_newtable(L); 

// store said table (pop top of the stack) in pseudo-registry
int tab_idx = luaL_ref(L, LUA_REGISTRYINDEX); 

// retrieve back the table for functions on top of the stack
lua_rawgeti(L, LUA_REGISTRYINDEX, tab_idx);

// retrieve function named "f" to store, put it on top of the stack
lua_getglobal(L, "f"); 

// store a function (pop top of the stack) in the function table
// -2 here stands for "stack top-1 element" -- the retrieved table for functions
int t = luaL_ref(L, -2); 

// we are done with the function table (remaining stack object), so pop it
lua_pop(L, 1);



检索


// retrieve function table, put it on top of the stack
lua_rawgeti(L, LUA_REGISTRYINDEX, tab_idx);

// retrieve function from the table, put it on top of the stack
lua_rawgeti(L, -1, t); 

/* use the function ... */

// don't forget to pop returned value and function table from the stack
lua_pop(L, 2);

    

	



    

    


  

  

    
最新问题


  





  

    © www.soinside.com 2019 - 2024. All rights reserved.