在lua中调用c函数，我们通常要将c函数转换成相应的注册函数，也就是如下形式
int function(lua_State *L) {}
可是如果我们每个都函数都这么写，既重复了太多的工作量，又容易出错，所以自然想到了用一层代理来连接注册函数与本来的c函数。于是我们可以这样
int function(lua_State *L)
{
//do something
return callfun(); //这里callfun()就调用了我们本来的c函数
}
可是对于callfun我们怎么实现呢。在c语言里面，我们可以使用函数指针来实现我们的函数功能。如对于函数 int myprint()，我们可以声明一个 int(*fn)() = myprint指针，然后通过fu()调用，这样就跟直接调用myprint()一样了，所以我们考虑callfun函数如下:
template <typename RT>
int callfun(RT (*func)(), lua_State *L, int index )
{
RT ret = func(); //调用函数，得到返回值
Push(L, ret); //将返回值压入lua堆栈
return 1;
}
这里实现的是形如RT fun() 的函数调用，对于有多个参数的情况，我们可以定义不同的callfun函数重载实现，如
template <typename RT, typename P1>
int callfun(RT (*func)(P1), ……)
这样定义有虽然实现起来比较简单，但是对于参数较多的情况就比较难以书写了，不过对于一般的函数，参数都不可能太多（如果太多了我想应该就要重写该函数了），所以我们就按照这样实现。
由于考虑到简易说明，声明要处理的函数类型为 int fun()，既参数为0返回值为int。
于是我们可以定义我们的代理注册函数如下
template <typename Func>
int registry_function(lua_State *L);
现在我们需要做的就是怎样把我们的函数指针在代理注册里面传给callfun，这里我们需要用到一些lua的实现方法，当lua在把c函数压入堆栈的时候，会把参数存储到upvalue里面，而我们会把registry_function压入堆栈，所以很自然的我们将把upvalue的第一个值作为函数指针的值。而对于函数指针来说，在lua里面就是一个userdata，所以我们可以这样实现：
template <typename Func>
int registry_function(lua_State *L)
{
//取出函数指针
unsigned char* buffer = (unsigned char*)lua_touserdata(L, lua_upvalueindex(1));
//调用函数
return callFunc(*(Func*)(buffer), L, 1);
}
下面我们的问题就在于怎么样把函数指针放入upvalue中以及将我们的代理注册函数注册进lua，我们定义如下函数：
template <typename Func>
void lua_pushdirectclosure(lua_State *L, Func func, unsigned int nupvalues)
{
//创建userdata并把func指针的值拷贝进去
unsigned char* buffer = (unsigned char*)lua_newuserdata(L, sizeof(func));
memcpy(buffer, &func, sizeof(func));
lua_pushcclosure(L, registry_function <Func>, nupvalues + 1);
}
首先我们创建一个userdata并把函数指针赋值给它，然后将registry_function注册给lua，这时由于userdata为第一个参数，所以我们可以在调用registry_function的时候取出使用。在通过call函数调用原本的c函数。
为了考虑到方便实现，我们定义一个宏：
#define lua_directregistry_function(L, func) /
lua_pushstring(L, #func); /
lua_pushdirectclosure(L, func, 0); /
lua_settable(L, LUA_GLOBALSINDEX);
在程序里面，假设我们的函数为 int myprint() {}
则我们在c语言里面使用如下
lua_directregistry_function(L, myprint);
然后在lua里面就可以通过myprint()调用该函数了。
以上是实现的在lua里面对不同类型的c语言函数进行封装调用，其实重点就是通过改函数的函数指针来进行操作，其实对于类里面的成员函数，我们同样可以注册进入lua，然后像一般函数进行调用。
对于类的成员函数，我们需要类的成员函数指针来操作，假设有一个类
class A
{
public:
int test();
};
我们可以这样定义test的函数指针
int (A::*fun)();
fun = &A::test;
使用的时候我们可以这样：
A a;
(a.*fun)();
对以对我们来说，实现类的成员函数注册重点就是操作类的成员函数的函数指针。我们仍然把该函数指针存放到upvalue的第一个值处。
首先是call函数声明，由于有了类，所以如下：
template <typename Cla, typename RT>
int callfunc(Cla &cla, RT (Cla::*func)(), … …)
{
RT ret = (cla.*func)();
//do something
}
然后就是把成员函数指针的值拷入userdata中：
unsigned char* buffer = (unsigned char*)lua_newuserdata(L, sizeof(Cla) + sizeof(func));
memcpy(buffer, &cla, sizeof(Cla));
memcpy(buffer + sizeof(Cla), &func, sizeof(func));
而在我们的代理注册函数里面，调用call函数如下：
callfunc(*(Cla*)buffer, *(Func*)(buffer + sizeof(Cla)), L, 1);
由于对于一般的类成员函数来说（静态除外），我们的调用方式是class.function()，所以在userdata中我们需要保存两个值，一个是该类的地址，一个是类的函数的地址。
这样我么就可以把类的成员函数也注册给了lua。
以下为C函数与类成员函数封装代码（为了简便，函数都是 int fun() 形式）：
/*
调用真正的C函数，现已int func()作为特例。
参数 func 函数指针，指向参数为返回值为int类型的函数
L lua变量
index lua栈中索引
对于其他的类型，可用模板实现
如对于一个参数的函数，实现如下
template <typname RT, typename P1>
int callFunc(RT (*func)(P1), lua_state *L, int index)
{
//Get 通过index索引得到在lua栈中的值并转换成P1类型
//Push 把函数的返回值压入堆栈
RT ret = func(Get(Type<P1>(), L, index + 0));
Push(L, ret);
return 1;
}
*/
int callFunc(int (*func)(), lua_State *L, int index)
{
int ret = func();
lua_pushnumber(L, ret);
return 1;
}
//函数指针相关数据会存到UpValue的第一个值中，此处从upvalue中取出
unsigned char* getFirstUpValue(lua_State *L)
{
unsigned char* buffer = (unsigned char*)lua_touserdata(L, lua_upvalueindex(1));
return buffer;
}
/*
实现callFunc的lua调用形式封装
*/
template <typename Func>
int directCallFunc(lua_State *L)
{
//得到函数指针
unsigned char* buffer = getFirstUpValue(L);
//转换成相应的函数调用
return callFunc(*(Func*)(buffer), L, 1);
}
/*
将directCallFunc注册进lua
*/
template <typename Func>
void lua_pushdirectclosure(lua_State *L, Func func, unsigned int nupvalues)
{
//创建userdata并把func指针的值拷贝进去
unsigned char* buffer = (unsigned char*)lua_newuserdata(L, sizeof(func));
memcpy(buffer, &func, sizeof(func));
lua_pushcclosure(L, directCallFunc<Func>, nupvalues + 1);
}
/*
实现对class里面memeber function的调用
参数cla 要调用的类的实例
Cla::*func 类的函数指针
*/
template <typename Cla>
int callMemFunc(Cla &cla, int (Cla::*func)(), lua_State *L, int index)
{
int ret = (cla.*func)();
lua_pushnumber(L, ret);
return 1;
}
/*
实现callMemFunc的lua调用形式封装
*/
template <typename Cla, typename Func>
int directCallMemFunc(lua_State *L)
{
//得到函数指针
unsigned char* buffer = getFirstUpValue(L);
//转换成相应的函数调用
return callMemFunc(*(Cla*)(buffer), *(Func*)(buffer + sizeof(Cla)), L, 1);
}
/*
将directCallMemFunc注册进lua
*/
template <typename Cla, typename Func>
void lua_pushdirectmemclosure(lua_State *L, Cla &cla, Func func, unsigned int nupvalues)
{
//创建userdata并把cla和func指针的值拷贝进去
unsigned char* buffer = (unsigned char*)lua_newuserdata(L, sizeof(Cla) + sizeof(func));
memcpy(buffer, &cla, sizeof(Cla));
memcpy(buffer + sizeof(Cla), &func, sizeof(func));
lua_pushcclosure(L, directCallMemFunc<Cla, Func>, nupvalues + 1);
}
#define lua_directregistry_function(L, func) /
lua_pushstring(L, #func); /
lua_pushdirectclosure(L, func, 0); /
lua_settable(L, LUA_GLOBALSINDEX);
#define lua_directregistry_memfunction(L, name, cla, func) /
lua_pushstring(L, name); /
lua_pushdirectmemclosure(L, cla, func, 0); /
lua_settable(L, LUA_GLOBALSINDEX);
使用的时候我们通过lua_directregistry_function()注册c函数，
通过lua_directregistry_memfunction()注册类成员函数，其中name为该成员函数在lua中使用的函数名。