函数指针的C ++ lua桥问题

Question

I am trying to create a simple c++ wraper over *lua_CFunction* and it is defined like :

// header
typedef int (*lua_CFunction) (lua_State* lua);
...
lua_CFunction wrap (std::function <int (Game* game)> function);
// implementation
lua_CFunction ScriptingInterface::wrap (std::function <int (Game* game)> function) 
{
    return [this, function] (lua_State* unused) -> int {
        int n_args = function (this->game);
        return n_args;
    };
}
void ScriptingInterface::registerFunction (std::string name, std::function <int (Game* game)> function) 
{
    lua_register (lua, name.c_str (), wrap (function));
}

The idea is to create public functions like this :

int setTitle (Game* interface) 
{
    const char* title = lua_tostring (interface->getScripts ()->getLuaState (), 1);

    SDL_WM_SetCaption (title, NULL);

    return 0;
}

And share them with lua like :

scripts->registerFunction ("setTitle", setTitle);

scripts is an instance of ScriptingInterface

The problem occurs when trying to compile the game.

./scripting/scripting_interface.cc: In member function ‘int (* ScriptingInterface::wrap(std::function<int(Game*)>))(lua_State*)’:
./scripting/scripting_interface.cc:40:2: error: cannot convert ‘ScriptingInterface::wrap(std::function<int(Game*)>)::<lambda(lua_State*)>’ to ‘int (*)(lua_State*)’ in return
./scripting/scripting_interface.cc:41:1: warning: control reaches end of non-void function [-Wreturn-type]

Could anyone tell me what I am doing wrong in here, because AFAIK the code should compile without any problem?

Answer 1

The problem is here:

lua_CFunction ScriptingInterface::wrap(std::function<int(Game*)> function) 
{
    return [this, function] (lua_State* unused) -> int {
        int n_args = function (this->game);
        return n_args;
    };
}

You are trying to return a lambda where a function pointer is expected, but a capturing lambda cannot be converted to a function pointer - and your lambda is capturing both this and function . Per Paragraph 5.1.2/6 of the C++11 Standard:

The closure type for a lambda-expression with no lambda-capture has a public non-virtual non-explicit const conversion function to pointer to function having the same parameter and return types as the closure type's function call operator. The value returned by this conversion function shall be the address of a function that, when invoked, has the same effect as invoking the closure type's function call operator.

Unfortunately, unless you can return an std::function<int(lua_State*)> , you will have to change your design.