一个使用c++在lua中创建自定义数据类型的简易方法

来源：互联网发布：宿州淘宝招聘信息编辑：程序博客网时间：2024/05/16 12:05

luabind

一个使用c++在lua中创建自定义数据类型的简易方法

分类：游戏编程2010-04-15 20:12 1774人阅读评论(0) 收藏举报

luac++constructorclassfunctionbuild

lua是一个内嵌式的语言，很多初学者对于lua中使用c++类中的函数，或者用c++直接创建一个自己的自定义数据类型比较头疼，因为这部分确实比较乱，牵扯到内存释放分配等问题，但是如果把其中关系理清，还是很简单的，下面这段代码是一个老外写的，我做了一些修改。首先看代码。

[cpp] view plaincopy
#ifndef LUNA_H  
#define LUNA_H 1  
  
  
/**************************************************************************** 
* This program is free software. It comes without any warranty, to          * 
* the extent permitted by applicable law. You can redistribute it           * 
* and/or modify it under the terms of the Do What The Fuck You Want         * 
* To Public License, Version 2, as published by Sam Hocevar. See            * 
* http://sam.zoy.org/wtfpl/COPYING for more details.                        * 
****************************************************************************/  
  
/****************************************************************************** 
* 这是一个自由传播修改的文件，如果你够厚道就保留下我的签名吧               * 
* Edit by fox                                                                 * 
* 2010-4-13                                                                   * 
* http://blog.csdn.net/limiteee                                               * 
******************************************************************************/  
  
// convenience macros  
//注册一个自定义类型，并用该类名创建一个元表  
#define luna_register(L, klass) (Luna<klass>::Register((L)))  
  
//注册一个自定义数据类型，并用该类名创建一个元表，该类必须是一个Ogre::Singleton的派生类，一般用于lua访问c环境中全局唯一实例的类  
#define luna_register_singleton(L, klass) (Luna<klass>::Register_singleton((L)))  
#define luna_registermetatable(L, klass) (Luna<klass>::RegisterMetatable((L)))  
#define luna_inject(L, klass, t) (Luna<klass>::inject((L), (t)))  
  
#define luna_flag_meta_func     0  
#define luna_flag_func          1  
  
  
  
/* 
---------------------------------------------------------------------------------------------------------- 
LUNA_CLASS_D_DEFAULT_VALS                           需要写在类声明中 
LUNA_CLASS_D_INIT_VALS_CLASSNAME                    写在类实现中 
LUNA_CLASS_D_INIT_VALS_FUNCNAME_START               开始进行lua声明，必须以这个宏开始 
LUNA_CLASS_D_INIT_VALS_FUNCNAME_END                 lua声明结束，必须以这个宏结束 
LUNA_CLASS_D_INIT_VALS_FUNCNAME_USER                进行用户自定义函数的lua声明 
LUNA_CLASS_D_INIT_VALS_META_FUNCNAME_USER           定义一个元表的方法 
LUNA_CLASS_D_INIT_VALS_META_FUNCNAME_ALIAS_USER     定义一个元表的方法，并且使用指定的别名 
 
BUILD_LUACLASS                                      在lua中创建一个指定类的自定义数据，new一个该类指针赋予这个自定义数据 
BUILD_LUACLASS_LP                                   在lua中创建一个指定类的自定义数据，使用一个已经存在的该类指针赋予这个自定义数据 
 
cLinkName               可以是任何类，没有规定，这个类只是给lua类进行访问的。 
cName                   是lua类，这个类将可以在lua中访问 
---------------------------------------------------------------------------------------------------------- 
*/  
  
#define LUNA_CLASS_D_DEFAULT_VALS(cName,cLinkName) /  
    public: /  
    static cLinkName *m_pLink; /  
    static const char className[]; /  
    static const Luna<cName>::RegType Register[];  
  
  
#define LUNA_CLASS_D_INIT_VALS_CLASSNAME(cName,cLinkName) /  
    cLinkName *cName::m_pLink = 0; /  
    const char cName::className[] = #cName;  
#define LUNA_CLASS_D_INIT_VALS_CLASSNAME_ALIAS(cName,cLinkName,Alias) /  
    cLinkName *cName::m_pLink = 0; /  
    const char cName::className[] = Alias;  
  
#define LUNA_CLASS_D_INIT_VALS_FUNCNAME_START(cName) /  
    const Luna<cName>::RegType cName::Register[] = {  
  
#define  LUNA_CLASS_D_INIT_VALS_FUNCNAME_USER(fName,cName) /  
    {#fName,&cName::fName},  
  
#define  LUNA_CLASS_D_INIT_VALS_FUNCNAME_ALIAS_USER(fName,cName,Alias) /  
    {Alias,&cName::fName},  
  
#define LUNA_CLASS_D_INIT_VALS_FUNCNAME_END                 { 0 }};  
  
#define LUNA___INDEX_FUNCTION                       -1  
  
#define BUILD_LUACLASS(ClassName, L)                        Luna<ClassName>::constructor( L )  
#define BUILD_LUACLASS_LP(ClassName, L, ClassPtr)           Luna<ClassName>::constructor_lightptr( L, ClassPtr );  
//  
//extern "C" {  
//#include "lua.h"  
//#include "lualib.h"  
//#include "lauxlib.h"  
//}  
#include "lua.hpp"  
  
template<class T> class Luna {  
public:  
    //注册唯一实例的对象------------------------------------------------------------------------------------------------------------------------------------------------  
    static void Register_singleton(lua_State *L) {  
        const char* cn = T::className;  
        lua_pushcfunction(L, &Luna<T>::constructor_singleton);  
        lua_setglobal(L, T::className); // T() in lua will make a new instance.  
    }  
    //使用一个c环境中已存在的指针创建一个自定义数据，该指针需要c来释放，这个方法没有注册gc函数  
    static int constructor_lightptr(lua_State *L, T* obj) {  
        return inject_singleton(L, obj);  
    }  
    //使用一个Ogre::Singleton的派生类的指针创建一个自定义数据，该指针需要c来释放，这个方法没有注册gc函数  
    static int constructor_singleton(lua_State *L) {  
        return inject_singleton(L, static_cast<T*>(T::getSingletonPtr()));  
    }  
    static int inject_singleton(lua_State *L, T* obj) {  
        //创建一个自定义数据，返回一个指向指针的指针,这里不使用light udata是因为我们需要lua为我们管理内存回收  
        T** a = static_cast<T**>(lua_newuserdata(L, sizeof(T*)));  
        *a = obj; // 指针的指针赋值  
  
        const char *cn = T::className;  
  
        int rt = luaL_newmetatable(L, T::className); // get (or create) the unique metatable  
  
        if ( rt )  
        {  
            //设置一个默认的__index函数  
            lua_pushstring(L, "__index");  
            lua_pushnumber(L, LUNA___INDEX_FUNCTION);  
            lua_pushcclosure(L, &Luna<T>::thunk, 1);  
            lua_settable(L, -3);  
  
            //-----------------------------------------------------------------------  
            //为元表添加方法  
  
            for (int i = 0; T::Register[i].name; i++) { // register the functions  
                lua_pushstring(L, T::Register[i].name);  
                lua_pushnumber(L, i); // let the thunk know which method we mean  
                lua_pushcclosure(L, &Luna<T>::thunk, 1);  
                lua_settable(L, -3); // self["function"] = thunk("function")  
            }  
        }  
  
        //-----------------------------------------------------------------------  
        lua_setmetatable(L, -2); //将自定义数据的元表设置为刚刚创建的表  
  
        return 1;  
    }  
  
    //这里注册可自动回收的对象---------------------------------------------------------------------------------------------------------------------  
    static void Register(lua_State *L) {  
        const char* cn = T::className;  
        lua_pushcfunction(L, &Luna<T>::constructor);  
        lua_setglobal(L, T::className); // T() in lua will make a new instance.  
    }  
  
    static int constructor(lua_State *L) {  
        return inject(L, new T(L));  
    }  
    static int inject(lua_State *L, T* obj) {  
        //创建一个自定义数据，返回一个指向指针的指针,这里不使用light udata是因为我们需要lua为我们管理内存回收  
        T** a = static_cast<T**>(lua_newuserdata(L, sizeof(T*)));  
        *a = obj; // 指针的指针赋值  
  
        const char *cn = T::className;  
  
        int rt = luaL_newmetatable(L, T::className); // get (or create) the unique metatable  
  
        if ( rt )  
        {  
            //设置一个默认的__index函数  
            lua_pushstring(L, "__index");  
            lua_pushnumber(L, LUNA___INDEX_FUNCTION);  
            lua_pushcclosure(L, &Luna<T>::thunk, 1);  
            lua_settable(L, -3);  
  
            //设置自动销毁函数  
            lua_pushstring(L, "__gc");  
            lua_pushcfunction(L, &Luna<T>::gc_obj);  
            lua_settable(L, -3); // metatable["__gc"] = Luna<T>::gc_obj  
            //-----------------------------------------------------------------------  
            //为元表添加方法  
  
            for (int i = 0; T::Register[i].name; i++) { // register the functions  
                lua_pushstring(L, T::Register[i].name);  
                lua_pushnumber(L, i); // let the thunk know which method we mean  
                lua_pushcclosure(L, &Luna<T>::thunk, 1);  
                lua_settable(L, -3); // self["function"] = thunk("function")  
            }  
        }  
  
        //-----------------------------------------------------------------------  
        lua_setmetatable(L, -2); //将自定义数据的元表设置为刚刚创建的表  
  
        return 1;  
    }  
    static int thunk(lua_State *L) {  
        // redirect method call to the real thing  
        int d = lua_gettop(L);  
        int i = (int)lua_tonumber(L, lua_upvalueindex(1)); // which function?  
        T** obj = static_cast<T**>(luaL_checkudata(L, 1, T::className));  //第一个参数就是他自己  
  
        //察看第二个参数是什么  
        int iType = lua_type(L, 2);  
  
        if (iType == LUA_TSTRING) {  
            //如果第二个参数是字符型，那么它可能是一个call调用  
            int rt = call_obj(L);  
            //如果调用发现同名函数那么执行它，并且返回  
            if ( rt ) {  
                return rt;  
            }  
        }  
  
        //每次调用使用的是目标对象来调用，所以函数访问的内部变量就是他自己的  
        return ((*obj)->*(T::Register[i].mfunc))(L); // execute the thunk  
    }  
    static int call_obj(lua_State *L) {  
        int d = lua_gettop(L);  
        T** obj = static_cast<T**>(luaL_checkudata(L, 1, T::className));  //第一个参数就是他自己  
        const char* funcname = lua_tostring(L, 2);  
        for (int i = 0; T::Register[i].name; i++) {  
            if( strcmp( funcname, T::Register[i].name ) == 0 ) {  
                //找到这个函数，并且返回它  
                lua_pushnumber(L, i); // let the thunk know which method we mean  
                lua_pushcclosure(L, &Luna<T>::thunk, 1);  
                return 1;  
            }  
        }  
        return 0;  
    }  
    static int gc_obj(lua_State *L) {  
        // clean up  
        //printf("GC called: %s/n", T::className);  
        T** obj = static_cast<T**>(luaL_checkudata(L, -1, T::className));  
        delete (*obj);  
        return 0;  
    }  
  
    struct RegType {  
        const char *name;  
        int(T::*mfunc)(lua_State*);  
    };  
};  
  
  
#endif /* LUNA_H */  

0 0