模板产生式编程，奇技淫巧也是临门一脚

ACGFan · 发表于 2007-1-7 20:27:00

我编写Lua中C API的C++封装时，面临这样一个问题：让Lua使用C++中用户定义的类接口和函数，大概形式就是：
C++:
class C
{
public:
T f(A1,A2);
};

Lua:
function run_host(c,a1,a2)
return c:f(a1,a2)
end

这个时候最直接的方法，就是做一个metatable mt，使mt.__index = mt，并设置mt["f"] = fun。fun是一个lua_CFunction,lua.h中定义typedef int (*lua_CFunction) (lua_State *L) )。然后每次将C对象的地址当作void*送到Lua端时，将其metatable设置为mt（lua只允许table和userdata拥metatable ），这样脚本端调用c的f时会查找出fun并调用fun(c,a1,a2)。
注意一下可以发现，调用C::f，有固定的机械行为：
int fun(lua_State* L)
{
C* c;
GetValue(&c,L,1);
A1 a1;
GetValue(&a1,L,2);
A2 a2;
GetValue(&a2,L,3);
//取参数
PushValue(L,c->f(a1,a2));
//调用，将结果压栈
return 1;
}

也就是说对于所有型为T(C::*f)(A1,A2)的成员函数，都存在一个lua_CFunction fun，使fun(c,a1,a2)等效于c->f(a1,a2)。
只要把这个套路告诉编译器，让它见到T(C::*f)(A1,A2)就给我生成一个fun就完事了。
主要问题就是这个fun。说的清，道的明，但是怎么样让编译器反映过来是个问题。

出发条件
1)非类型模板参数包括成员函数指针。
2)参数与返回值确定的函数也可以是模板函数，可对其特化版本取址，比如：
template<class T>
void Delete(void* p)
{
delete reinterpret_cast<T*>(p);
}
void(* pdelete)(void*) = Delete<int>;

先考虑怎样对固定类型Test生成这样一个lua_CFunction:
class Test
{
public:
int f1(const char*);
int f2(const char*);
};

template<int(Test::*mf)(const char*)>
int lua_fun(lua_State* L)
{
  Test* t;
  GetValue(&t,L,2);
  const char* s;
  GetValue(&s,L,2);
  PushValue(L,(*t.*mf)(s))

  return 1;
}

为了这一步能走通，首先提供了两大组重载函数GetValue和PushValue。
lua_CFunction f1 = lua_fun<&Test::f1>,f2 = lua_fun<&Test::f2>;

现在将Test，int，const char* 都泛化：

template<class T,class R,class A>
class LuaFunMaker
{
template<R(T::*mf)(A)>
static lua_fun(lua_State* L)
{
  T* t;
  GetValue(&t,L,2);
  A s;
  GetValue(&s,L,2);
  PushValue(L,(*t.*mf)(s))

  return 1;
}
};

lua_CFunction f = LuaFunMaker<int,Test,const char*>::lua_fun<&Test::f1>;

这里要注意的是，现有模板机制不能对一个任意类型的非类型模板参数，一次推导出该参数的类型。
不使用偏特化你不能写出可以这样使用的模板：
t<&C::f>
t<32>//不过可以写出：t<int,32>
//C任意类型
所以需要先推导出C的类型，再取相关的非类型模板参数，形如:f(exp).f<exp>();

核心部分基本完工了，但可以再尽善尽美一下，最终解决方案是加了一个小小间接层次，使用如下：
lua_CFunction f = LuaFunMake(&Test::f1).get<&Test::f1>();
定义一个宏辅助减少输入
#define FUN2LUA(mf) LuaFunMake(mf).get<mf>()
lua_CFunction f = FUN2LUA(&Test::f1);
至此使用已无额外记忆负担。
最终的实现比这个还要复杂很多，但是所用的模板技术，早有文章介绍，所以不再重复。

总结：这里解决的是这样一种问题：特殊情况下，虽然存在一种生成新类或函数的最直观的解决方案（本例为生成lua_CFunction），但是缺乏一般语言特性支持，此时可以考虑使用复杂的模板技巧，因为模板的推演能力能帮助生成新方法。

闲话：C++的很多特殊技巧并不推荐常驻备选方案，但是当你有一个逻辑上非常有效，现实中却难以下手的计划时，奇技淫巧可能是最后一支机动兵力。

我知道还有lua-bind等可用，但本库的目的和实现都是特别的。
该库我仍在更新，下载地址为：
http://free5.ys168.com/?qslash
本文相关内容见
lua\functionwrap.h
lua\classregister.h

使用介绍在
http://www.luachina.net/bbs/624/ShowPost.aspx

ACGFan = qslash

编译器使用VC8.0

第一次写比较长的贴，问题肯定不少，如果指出我会修改。

inoname · 发表于 2007-1-8 03:00:00

http://lua-users.org/wiki/SimplerCppBinding
也是用模板

ACGFan · 发表于 2007-1-8 10:35:00

功能不一样，我的设计不需要侵入修改类本身，类本身可以对Lua的存在一无所知，只要在任意CPP文件中对定义调用方式即可。
比如：
BEGIN_CLASS2LUA(std::vector<int>)
LUA_METHOD(push_back)
END_CLASS2LUA

vector<int> v;
d["vector"] = v;
(d["vector"]->*"push_back")(3);

cout<<v.size()<<endl<<v[0]<<endl;
输出
1
3

geniemaster · 发表于 2007-1-8 14:00:00

非常出色的东西，多谢楼主。

免费打工仔 · 发表于 2007-1-12 01:28:00

黑猫白猫能抓住老鼠就是好猫

楼主赞一个。

之前小弟我也写了一个从C++ 调用lua的封装。
挺漂亮，可惜不是很实用。所以最后就没用上。

使用方法是
lua_State * L = luaL_newstate();;
LuaFunction lua(L);
lua::exe(“function1”,result, parameter0, parameter1) ;//六个以内参数，常用数据类型支持。

里面都是使用内联和模板，效率不差，展开代码也都和手写一样，只是好看一些。

#ifndef LUAFUNCTION_H
#define LUAFUNCTION_H
extern "C" {
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
class VOID{};
class NUL{};
template<class Q>
class Push{};
template<>
class Push<int>
{
public:
inline static void push(lua_State * L, int q)
{
lua_pushnumber(L, q);
}
};
template<>
class Push<float>
{
public:
inline static void push(lua_State * L, int q)
{
lua_pushnumber(L, q);
}
};
template<>
class Push<bool>
{
public:
inline static void push(lua_State * L, bool q)
{
lua_pushboolean(L, q);
}
};
template<>
class Push<const char *>
{
public:
inline static void push(lua_State * L, const char * q)
{
lua_pushstring(L, q);
}
};
template<>
class Push<char *>
{
public:
inline static void push(lua_State * L, const char * q)
{
Push<const char *>::push(L, q);
//lua_pushstring(L, q);
}
};
template<>
class Push<std::string>
{
public:
inline static void push(lua_State * L, std::string & q)
{
Push<const char *>::push(L, q.c_str());
//lua_pushstring(L, q.c_str());
}
};
template<>
class Push<const NUL>
{
public:
inline static void push(lua_State * L, NUL)
{
lua_pushnil(L);
}
};
template<class R>
class Pop{};
template<>
class Pop<int>
{
public:
inline static void pop(lua_State * L, int &r,int n)
{
lua_pcall(L, n, 1, 0);
r = (int)lua_tonumber(L, -1);
}
};
template<>
class Pop<float>
{
public:
inline static void pop(lua_State * L, float &r,int n)
{
lua_pcall(L, n, 1, 0);
r = (float)lua_tonumber(L, -1);
}
};
template<>
class Pop<bool>
{
public:
inline static void pop(lua_State * L, bool &r,int n)
{
lua_pcall(L, n, 1, 0);
r = lua_toboolean(L, -1);
}
};
template<>
class Pop<std::string>
{
public:
inline static void pop(lua_State * L, std::string &r,int n)
{
lua_pcall(L, n, 1, 0);
r = lua_tostring(L, -1);
}
};
template<>
class Pop<char *>
{
public:
inline static void pop(lua_State * L, char *r,int n)
{
lua_pcall(L, n, 1, 0);
strcpy(r, lua_tostring(L, -1));
}
};
template<>
class Pop<const VOID>
{
public:
inline static void pop(lua_State * L, const VOID &r,int n)
{
lua_pcall(L, n, 0, 0);
}
};
class LuaFunction
{
private:
lua_State * _L;
public :
const static VOID VOID;
const static NUL NUL;
inline LuaFunction(lua_State * L):_L(L){}
template<class R>
inline void exe(const char * fun, R &r)
{
lua_getglobal(_L, fun);
Pop<R>::pop(_L, r, 0);
}
template<class R, class P0>
inline void exe(const char * fun, R &r, P0 p0)
{
lua_getglobal(_L, fun);
Push<P0>::push(_L, p0);
Pop<R>::pop(_L, r,1);
}
template<class R, class P0,class P1>
inline void exe(const char * fun, R &r, P0 p0, P1 p1)
{
lua_getglobal(_L, fun);
Push<P0>::push(_L, p0);
Push<P1>::push(_L, p1);
Pop<R>::pop(_L, r, 2);
}
template<class R, class P0,class P1,class P2>
inline void exe(const char * fun, R &r, P0 p0, P1 p1,P2 p2)
{
lua_getglobal(_L, fun);
Push<P0>::push(_L, p0);
Push<P1>::push(_L, p1);
Push<P2>::push(_L, p2);
Pop<R>::pop(_L, r, 3);
}
template<class R, class P0,class P1,class P2, class P3>
inline void exe(const char * fun, R &r, P0 p0, P1 p1, P2 p2, P3 p3)
{
lua_getglobal(_L, fun);
Push<P0>::push(_L, p0);
Push<P1>::push(_L, p1);
Push<P2>::push(_L, p2);
Push<P3>::push(_L, p3);
Pop<R>::pop(_L, r, 4);
}
template<class R, class P0,class P1,class P2, class P3, class P4>
inline void exe(const char * fun, R &r, P0 p0, P1 p1, P2 p2, P3 p3, P4 p4)
{
lua_getglobal(_L, fun);
Push<P0>::push(_L, p0);
Push<P1>::push(_L, p1);
Push<P2>::push(_L, p2);
Push<P3>::push(_L, p3);
Push<P4>::push(_L, p4);
Pop<R>::pop(_L, r, 5);
}
template<class R, class P0,class P1,class P2, class P3, class P4, class P5>
inline void exe(const char * fun, R &r, P0 p0, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
{
lua_getglobal(_L, fun);
Push<P0>::push(_L, p0);
Push<P1>::push(_L, p1);
Push<P2>::push(_L, p2);
Push<P3>::push(_L, p3);
Push<P4>::push(_L, p4);
Push<P5>::push(_L, p5);
Pop<R>::pop(_L, r, 6);
}
};
const VOID LuaFunction::VOID;
const NUL LuaFunction::NUL;
#endif

复制代码

虽然没有用上，但在这里供大家批评吧。Loki里面的函数对象比较好，任意参数类型任意数量。有时间能适配一下Lua应该不错。

ACGFan · 发表于 2007-1-12 10:44:00

谢谢。咱俩对“不同类型使用统一接口”的原始冲动相同，所以代码的body一样，只不过我比较懒，用的是函数重载。
Loki::Function/Loki::Functor配lua的想法很华丽。如果我使用在lua-stack上分配full-userdata的办法，在调用的lua-cfunction时候再加一个间接层次，即设置__call的metamethod，然后读出Loki::Function或Loki::Functor，那么确实可以做到把Loki::Function/Loki::Functor压入lua，然后由lua端调用。lua-bind似乎就是这个路子。
补充一下初始设计原则：
1)尽量把使用者学习负担降到0。
//所以调用lua-funtion是重载()，提领表成员用的是可以无限镶嵌的[]，交换数据尽量用 = 。常见写法就是Set(res) = r[..][..](..)，r1[..][..] = r2[..][..]。这样比用Call，Get之类成员函数直观。
2)尽量只表达C++和lua共有的概念。
3)不需要lua端了解C++，也不需要C++端了解lua，一切黏合工作在本库内完成。
4)尽量避免诱使用户的注意力放在本库上，使其能集中注意力在C++和lua的代码上。
所以我的用户定义类型接口是在全局域里用宏静态注册的（实际就是完成函数），不需要在函数体内写d.Register<..>()。希望用户能避免在函数体内作手续性质的代码。

zotin · 发表于 2007-1-20 12:17:00

Loki也不可能做到任意参数的。
好像最多是16个参数吧。一般不会有超过16个这么变态的函数了。
过度使用模版往往导致除错很麻烦。这一方面是编译器对模版支持不够，另一方面是模版本身的技巧已经太复杂了。

ACGFan · 发表于 2007-1-23 15:55:00

我写这篇的意思就是：把产生式编程手法作为功能而非框架使用。

账号		自动登录	找回密码
密码			立即注册

模板产生式编程，奇技淫巧也是临门一脚

Re:模板产生式编程，奇技淫巧也是临门一脚

Re:模板产生式编程，奇技淫巧也是临门一脚

Re:模板产生式编程，奇技淫巧也是临门一脚

Re: 模板产生式编程，奇技淫巧也是临门一脚

Re:模板产生式编程，奇技淫巧也是临门一脚

Re: 模板产生式编程，奇技淫巧也是临门一脚

Re:模板产生式编程，奇技淫巧也是临门一脚