技术说明 5

用于将 C++ 绑定到 Lua 的模板类

摘要

问题

解决方案

通过使用类的名称注册表构造函数来完成类注册。表构造函数是模板类的静态方法，它返回一个表对象。

注意：静态类成员函数与 C 函数兼容，假设它们的签名相同，因此我们可以将它们注册到 Lua 中。以下代码片段是模板类的成员函数，“T”是要绑定的类。

  static void Register(lua_State* L) {
    lua_pushcfunction(L, &Luna<T>::constructor);
    lua_setglobal(L, T::className);

    if (otag == 0) {
      otag = lua_newtag(L);
      lua_pushcfunction(L, &Luna<T>::gc_obj);
      lua_settagmethod(L, otag, "gc"); /* tm to release objects */
    }
  }

  static int constructor(lua_State* L) {
    T* obj= new T(L); /* new T */
    /* user is expected to remove any values from stack */

    lua_newtable(L); /* new table object */
    lua_pushnumber(L, 0); /* userdata obj at index 0 */
    lua_pushusertag(L, obj, otag); /* have gc call tm */
    lua_settable(L, -3);

    /* register the member functions */
    for (int i=0; T::Register[i].name; i++) {
      lua_pushstring(L, T::Register[i].name);
      lua_pushnumber(L, i);
      lua_pushcclosure(L, &Luna<T>::thunk, 1);
      lua_settable(L, -3);
    }
    return 1; /* return the table object */
  }

  static int thunk(lua_State* L) {
    /* stack = closure(-1), [args...], 'self' table(1) */
    int i = static_cast<int>(lua_tonumber(L,-1));
    lua_pushnumber(L, 0); /* userdata object at index 0 */
    lua_gettable(L, 1);
    T* obj = static_cast<T*>(lua_touserdata(L,-1));
    lua_pop(L, 2); /* pop closure value and obj */
    return (obj->*(T::Register[i].mfunc))(L);
  }

  static int gc_obj(lua_State* L) {
    T* obj = static_cast<T*>(lua_touserdata(L, -1));
    delete obj;
    return 0;
  }

• 它必须有一个采用 lua_State* 的公共构造函数
• 已注册的成员函数必须具有签名 int(T::*)(lua_State*)
• 它必须有一个名为 className 的 public static const char[] 成员
• 它必须有一个名为 Register 的 public static const Luna<T>::RegType[] 成员

Luna<T>::RegType 是一个函数映射。name 是成员函数 mfunc 将注册为的函数的名称。

  struct RegType {
    const char* name;
    const int(T::*mfunc)(lua_State*);
  };

  class Account {
    double m_balance;
   public:
    Account(lua_State* L) {
      /* constructor table at top of stack */
      lua_pushstring(L, "balance");
      lua_gettable(L, -2);
      m_balance = lua_tonumber(L, -1);
      lua_pop(L, 2); /* pop constructor table and balance */
    }

    int deposit(lua_State* L) {
      m_balance += lua_tonumber(L, -1);
      lua_pop(L, 1);
      return 0;
    }
    int withdraw(lua_State* L) {
      m_balance -= lua_tonumber(L, -1);
      lua_pop(L, 1);
      return 0;
    }
    int balance(lua_State* L) {
      lua_pushnumber(L, m_balance);
      return 1;
    }
    static const char[] className;
    static const Luna<Account>::RegType Register
  };

  const char[] Account::className = "Account";
  const Luna<Account>::RegType Account::Register[] = {
    { "deposit",  &Account::deposit },
    { "withdraw", &Account::withdraw },
    { "balance",  &Account::balance },
    { 0 }
  };

  [...]

  /* Register the class Account with state L */
  Luna<Account>::Register(L);

  -- In Lua
  -- create an Account object
  local account = Account{ balance = 100 }
  account:deposit(50)
  account:withdraw(25)
  local b = account:balance()

  0 = userdata(6): 0x804df80
  balance = function: 0x804ec10
  withdraw = function: 0x804ebf0
  deposit = function: 0x804f9c8

说明

Thunk 机制是该类的核心，因为它“Thunk”调用。它通过从函数调用关联的表中获取对象指针，并为成员函数指针索引成员函数映射来实现这一点。（Lua 表函数调用 table:function() 是 table.function(table) 的语法糖。当进行调用时，Lua 首先将表压入堆栈，然后压入任何参数）。成员函数索引是一个闭包值，最后压入堆栈（在任何参数之后）。最初，我将对象指针作为闭包，这意味着对于每个实例化的类，每个函数都有 2 个闭包值，一个指向对象（void*）的指针和一个成员函数索引（int）；这似乎相当昂贵，但可以快速访问对象指针。此外，表中需要一个用于垃圾回收目的的用户数据对象。最后，我选择为对象指针索引表并节省资源，从而增加了函数调用开销；对象指针的表查找。

综合考虑所有事实，该实现仅使用 Lua 的一些可用扩展机制，用于保存成员函数索引的闭包，“gc”标记方法用于垃圾回收，以及用于表构造函数和成员函数调用的函数注册。

为什么只允许注册具有签名 int(T::*)(lua_State*) 的成员函数？这允许您的成员函数直接与 Lua 交互；检索参数并将值返回 Lua，调用任何 Lua API 函数等。此外，它提供了 C 函数注册到 Lua 时具有的相同接口，从而使希望使用 C++ 的人更容易上手。

缺点

创建对象时只需新建，用户应该对如何创建对象有更多控制权。例如，用户可能希望注册一个单例类。一种解决方案是让用户实现一个静态的 create() 成员函数，该函数返回指向对象的指针。这样，用户就可以实现一个单例类，只需通过 new 分配对象或其他任何方式。可以修改 constructor 函数以调用 create() 而不是 new 来获取对象指针。这将更多策略推送到类中，但灵活性更高。垃圾回收的“挂钩”也可能对某些人有用。

结论

模板类的完整源代码（约 70 行源代码）可从 Lua 加载项页面获得。

参考