如何利用LuaBridge将C++模板工厂类暴露给Lua？

我之前在做C++项目时刚好遇到过把模板工厂通过LuaBridge暴露给Lua的需求，踩了不少坑，现在给你梳理一套可行的方案。

首先得明确核心问题：Lua是动态类型语言，而你的工厂是C模板类，LuaBridge没办法直接处理泛型参数，必须先把工厂实例化为具体类型再暴露；另外Lua无法直接创建C虚基类的派生对象（比如你的BaseCreator），所以注册类型的逻辑得在C++层做包装。

第一步：补全工厂的完整结构（基于你的代码片段） #

先把你提到的模板工厂补全成可运行的基础结构，假设所有可创建对象都继承自BaseObject：

// 所有可创建对象的基类
class BaseObject {
public:
    virtual ~BaseObject() = default;
    // 可添加业务相关的虚方法，比如update、print等
};

// 创建器虚基类
template <class Id>
class BaseCreator {
public:
    virtual ~BaseCreator() = default;
    virtual BaseObject* create() = 0;
};

// 绑定具体类型的创建器
template <class T, class Id>
class ConcreteCreator : public BaseCreator<Id> {
public:
    BaseObject* create() override {
        return new T();
    }
};

// 你的模板工厂类
template <class T, class Id>
class Factory {
private:
    std::map<Id, BaseCreator<Id>*> functionMap;
public:
    T* create(Id name) {
        auto iter = functionMap.find(name);
        if (iter != functionMap.end()) {
            return static_cast<T*>(iter->second->create());
        }
        return nullptr;
    }

    // 避免Lua直接操作Creator指针，提供模板化的注册接口
    template <class Derived>
    void registerType(Id name) {
        functionMap[name] = new ConcreteCreator<Derived, Id>();
    }

    ~Factory() {
        // 清理所有创建器，防止内存泄漏
        for (auto& pair : functionMap) {
            delete pair.second;
        }
    }
};

第二步：实例化具体工厂并准备LuaBridge绑定 #

LuaBridge只能处理具体类型，所以我们先实例化一个基于BaseObject和std::string（作为ID类型）的全局工厂：

// 全局实例化的工厂，也可以用单例模式封装
Factory<BaseObject, std::string> g_objectFactory;

接下来需要把BaseObject及其派生类注册到LuaBridge，让Lua能识别这些对象类型。比如假设我们有一个派生类Player：

// 示例派生类
class Player : public BaseObject {
private:
    std::string m_name;
public:
    void setName(const std::string& name) { m_name = name; }
    const std::string& getName() const { return m_name; }
};

注册类型到Lua的代码：

#include <LuaBridge/LuaBridge.h>

void registerLuaTypes(lua_State* L) {
    // 先注册基类BaseObject
    luabridge::getGlobalNamespace(L)
        .beginClass<BaseObject>("BaseObject")
        .endClass();

    // 注册派生类Player，关联到BaseObject
    luabridge::getGlobalNamespace(L)
        .deriveClass<Player, BaseObject>("Player")
        .addFunction("setName", &Player::setName)
        .addFunction("getName", &Player::getName)
        .endClass();
}

第三步：暴露工厂方法给Lua #

因为registerType是模板方法，Lua无法直接调用泛型接口，所以我们需要为每个要注册的派生类写包装函数（也可以用宏批量生成）：

void registerFactoryToLua(lua_State* L) {
    // 把全局工厂暴露为Lua全局变量
    luabridge::setGlobal(L, &g_objectFactory, "ObjectFactory");

    // 暴露工厂的create方法
    luabridge::getGlobalNamespace(L)
        .beginClass<Factory<BaseObject, std::string>>("Factory")
        .addFunction("create", &Factory<BaseObject, std::string>::create)
        .endClass();

    // 为Player类型写注册包装函数，Lua调用这个函数来注册Player
    luabridge::getGlobalNamespace(L)
        .addFunction("registerPlayerType", [](const std::string& name) {
            g_objectFactory.registerType<Player>(name);
        });

    // 如果有其他派生类，比如Enemy，同理添加包装函数
    // luabridge::getGlobalNamespace(L)
    //     .addFunction("registerEnemyType", [](const std::string& name) {
    //         g_objectFactory.registerType<Enemy>(name);
    //     });
}

第四步：Lua端的使用示例 #

现在你可以在Lua脚本里这样调用工厂系统：

-- 注册Player类型，标识为"player"
registerPlayerType("player")

-- 通过工厂创建Player对象
local player = ObjectFactory:create("player")

-- 调用Player的方法
player:setName("Alice")
print(player:getName()) -- 输出 Alice

关键注意事项 #

• 内存管理：工厂创建的对象默认由C++分配，你可以通过LuaBridge的addConstructor或所有权转移接口，让Lua的垃圾回收负责释放对象，避免内存泄漏。
• 派生类必须提前注册：所有要在Lua中使用的派生类，必须先在C++层注册到LuaBridge，否则create返回的指针无法被Lua识别为正确类型。
• 避免直接暴露Creator接口：Lua无法创建C的BaseCreator派生对象，所以一定要用C包装好的registerType接口来注册类型。

内容的提问来源于stack exchange，提问作者yik