C++导出类到lua:自动化

蔚落 2022-06-12 06:23 171阅读 0赞

这一章是在上一章的基础上写的，[如果不了解，请先看这里][Link 1]  
，自动化主要用到模板类，其他不多说，看代码：

template<typename CLASS>
    class   CELLRegister
    {
    protected:
        lua_State*  _vm;
    public:
        CELLRegister(lua_State*vm)
            :_vm(vm)
        {}
        ~CELLRegister()
        {}
    
        template<typename T>
        const char* getClassName()
        {
            //! pName = "class xxxx"
            //! 需要的是xxxx
            const char* pName    =   typeid(T).name();
    
            return  pName + 6;
        }
        /** * 开始导出函数 */
        CELLRegister&   begin()
        {
            //1. new method table 保存所有的函数
            lua_newtable(_vm);
    
            int methodTable = lua_gettop(_vm);
            //2. new metatable for L to save "__metatable", "__index", "__gc", etc
            luaL_newmetatable(_vm, getClassName<CLASS>() );
    
            int metaTable = lua_gettop(_vm);
    
            //3. metatable["__metatable"] = methodtable;同 lua_settable(1,metatable)
            lua_pushliteral( _vm, "__metatable" );
            lua_pushvalue( _vm, methodTable );
            lua_rawset( _vm, metaTable );
    
            //4. metatable["__index"] = methodtable ;同 lua_settable(1,metatable)
            lua_pushliteral( _vm, "__index" );
            lua_pushvalue( _vm, methodTable );
            lua_rawset( _vm, metaTable );  
    
            //5. metatable["__gc"] = myFunction 
            lua_pushliteral(_vm, "__gc" ); 
            lua_pushcfunction(_vm, CELLRegister<CLASS>::destryObject);
            lua_rawset( _vm, metaTable );
    
            lua_pop(_vm,1);
    
            return  *this;
        }
        /** * 导出函数 */
        template<typename Function>
        CELLRegister&   exp(Function func,const char* name)
        {
            int     size    =   sizeof(func);
            void*   data    =   lua_newuserdata(_vm, size);
            memcpy( data, &func, size);
    
            lua_pushcclosure(_vm, /*这里该怎么写*/, 1);
    
            lua_setfield(_vm, -2, name);
            return  *this;
        }
        /** * 完成导出 */
        void end()
        {
            const char* cName   =   getClassName<CLASS>();
            lua_pop(_vm,1);
            lua_register(_vm, cName , CELLRegister<CLASS>::createObject);
        }
    
        static int createObject( lua_State *L )
        {
            char*   name=   (char*)lua_tostring(L,-1);
            CLASS*  a   =   new CLASS(name);
            CLASS** p   =   (CLASS**)lua_newuserdata( L, sizeof(CLASS*));  
                    *p  =   a;
            luaL_getmetatable( L, "Enemy" );
            lua_setmetatable( L, -2 );
            return 1;
        }
        static int destryObject( lua_State *L )
        {
            CLASS*  obj   = (CLASS*)(*(void**)lua_touserdata(L,-1));
            delete  obj;
            return  0;
        }
    
    };
    
    
    int main(int argc,char** argv)
    {
        lua_State*  L   =   luaL_newstate();
        luaopen_base(L);                    
        luaopen_table(L);                   
        luaopen_io(L);                      
        luaopen_string(L);                  
        luaopen_math(L); 
    
    
    
        CELLRegister<Enemy> reg(L);
        reg.begin();
        reg.exp(&Enemy::getLife,"getLife");
        reg.exp(&Enemy::setLife,"setLife");
        reg.end();
    
    
        if( luaL_dofile( L, "main.lua" ))
        {  
            stackDump(L);
        }
        lua_close(L);
    
        return  0;
    }

[Link 1]: http://blog.csdn.net/s17728022507/article/details/75258480