c++ - Lua、C++ 和穷人的子类化

Question

我是 Bitfighter 的开发主管，我们正在混合使用 Lua 和 C++，使用 Lunar(Luna 的变体，可用 here)将它们绑定(bind)在一起。

我知道这个环境对面向对象和继承没有很好的支持，但我想找到一些方法来至少部分地解决这些限制。

这是我所拥有的:

C++ 类结构

    GameItem       |---- Rock       |---- Stone       |---- RockyStone    Robot

Robot implements a method called getFiringSolution(GameItem item) that looks at the position and speed of item, and returns the angle at which the robot would need to fire to hit item.

-- This is in Lua
angle = robot:getFiringSolution(rock)
if(angle != nil) then
    robot:fire(angle)
end

所以我的问题是我想将 rocks、stones 或 rockyStones 传递给 getFiringSolution 方法，但我不确定怎么做。

这只适用于 Rocks:

// C++ code
S32 Robot::getFiringSolution(lua_State *L) 
{
   Rock *target = Lunar<Rock>::check(L, 1);
   return returnFloat(L, getFireAngle(target));    // returnFloat() is my func
}

理想情况下，我想做的是这样的:

// This is C++, doesn't work
S32 Robot::getFiringSolution(lua_State *L) 
{
   GameItem *target = Lunar<GameItem>::check(L, 1);
   return returnFloat(L, getFireAngle(target));    
}

这个潜在的解决方案不起作用，因为 Lunar 的检查函数希望堆栈上的对象具有与为 GameItem 定义的类名相匹配的类名。 (对于您在 Lunar 注册的每个对象类型，您以字符串形式提供一个名称，Lunar 使用该名称来确保对象的类型正确。)

我会接受这样的事情，我必须检查每个可能的子类:

// Also C++, also doesn't work
S32 Robot::getFiringSolution(lua_State *L) 
{
   GameItem *target = Lunar<Rock>::check(L, 1);
   if(!target)
       target = Lunar<Stone>::check(L, 1);
   if(!target)
       target = Lunar<RockyStone>::check(L, 1);

   return returnFloat(L, getFireAngle(target));    
}

此解决方案的问题在于，如果堆栈中的项目类型不正确，检查函数会生成错误，并且我相信，从堆栈中删除了感兴趣的对象，因此我只有一次尝试获取

我想我需要从堆栈中获取指向 Rock/Stone/RockyStone 对象的指针，弄清楚它是什么类型，然后在使用它之前将其转换为正确的对象。

Lunar 进行类型检查的关键点是:

// from Lunar.h
// get userdata from Lua stack and return pointer to T object
static T *check(lua_State *L, int narg) {
  userdataType *ud =
    static_cast<userdataType*>(luaL_checkudata(L, narg, T::className));
  if(!ud) luaL_typerror(L, narg, T::className);
  return ud->pT;  // pointer to T object
}

如果我这样调用它:

GameItem *target = Lunar<Rock>::check(L, 1);

然后 luaL_checkudata() 检查堆栈中的项目是否为 Rock。如果是这样，一切都很好，它返回一个指向我的 Rock 对象的指针，该对象被传递回 getFiringSolution() 方法。如果堆栈上有非 Rock 项目，则转换返回 null，并调用 luaL_typerror()，这会将应用程序发送到 lala land(错误处理打印诊断信息并以极端偏见终止机器人)。

关于如何推进这件事有什么想法吗？

非常感谢!!

我想出的最佳解决方案...丑陋，但有效

根据下面的建议，我想到了这个:

template <class T>
T *checkItem(lua_State *L)
{
   luaL_getmetatable(L, T::className);
   if(lua_rawequal(L, -1, -2))         // Lua object on stack is of class <T>
   {
      lua_pop(L, 2);                   // Remove both metatables
      return Lunar<T>::check(L, 1);    // Return our object
   }
   else                                // Object on stack is something else
   {
      lua_pop(L, 1);    // Remove <T>'s metatable, leave the other in place 
                        // for further comparison
      return NULL;
   }
}

然后，以后……

S32 Robot::getFiringSolution(lua_State *L)
{
   GameItem *target;

   lua_getmetatable(L, 1);    // Get metatable for first item on the stack

   target = checkItem<Rock>(L);

   if(!target)
      target = checkItem<Stone>(L);

   if(!target)
      target = checkItem<RockyStone>(L);

   if(!target)    // Ultimately failed to figure out what this object is.
   {
      lua_pop(L, 1);                      // Clean up
      luaL_typerror(L, 1, "GameItem");    // Raise an error
      return returnNil(L);                // Return nil, but I don't think this 
                                          // statement will ever get run
   }

   return returnFloat(L, getFireAngle(target));    
}

我可以用它做进一步的优化......我真的很想弄清楚如何将它折叠成一个循环，因为实际上，我要处理的类要多于三个，并且这个过程有点麻烦。

对上述解决方案略有改进

C++:

GameItem *LuaObject::getItem(lua_State *L, S32 index, U32 type)
{
  switch(type)
  {
    case RockType:
        return Lunar<Rock>::check(L, index);
    case StoneType:
        return Lunar<Stone>::check(L, index);
    case RockyStoneType:
        return Lunar<RockyStone>::check(L, index);
    default:
        displayError();
   }
}

然后，以后……

S32 Robot::getFiringSolution(lua_State *L)
{
   S32 type = getInteger(L, 1);                 // My fn to pop int from stack
   GameItem *target = getItem(L, 2, type);

   return returnFloat(L, getFireAngle(target)); // My fn to push float to stack  
}

Lua 辅助函数，包含在一个单独的文件中，以避免用户需要手动将其添加到他们的代码中:

function getFiringSolution( item )
  type = item:getClassID()      -- Returns an integer id unique to each class
  if( type == nil ) then
     return nil
   end
  return bot:getFiringSolution( type, item )
end 

用户从 Lua 中这样调用:

   angle = getFiringSolution( item )

Answer 1

我认为您试图在错误的地方执行方法分派(dispatch)。 (这个问题是 所有 使 Lua 与 C 或 C++ 交互的“自动化”方式存在困难的征兆:对于它们中的每一个，幕后都有一些魔法在进行，而且并不总是如何让它工作很明显。我不明白为什么更多的人不只使用 Lua 的 C API。)

我查看了 Lunar 网页，在我看来您似乎需要创建一个 methods类型表 T然后调用Luna<T>::Register方法。有一个 simple example on the web .如果我正确阅读了代码，那么您问题中的胶水代码实际上都不是使用 Lunar 做事的推荐方法。 (我还假设您可以完全将这些方法实现为 C++ 调用。)

这一切都非常狡猾，因为有关 Lunar 的文档很薄。一个明智的选择是自己完成所有工作，并将每个 C++ 类型与包含其方法的 Lua 表相关联。然后你有 Lua __index元方法查询该表，Bob 是你的叔叔。 Lunar 正在做一些与这些接近的事情，但是它充分地使用了 C++ 模板来装饰我不确定如何让它工作的其他 goo。

模板的东西非常聪明。您可能想要花时间深入了解它的工作原理，或者重新考虑是否要使用它以及如何使用它。

总结:对于每个类，制作一个明确的方法表，并使用农历注册每个类Register方法。或者自己动手。