先来1段废话
c++ 从不会到现在  四舍五入后都有两年吧
初时觉得c++很深奥
学会了就觉得博大精深
现在也算是比较熟练吧 就觉得c++ 麻烦得很特别 就是特别麻烦=.=!
c++的麻烦就在于oop的支持不够多
委托就是其中1个
还有其他1些例如"虚构造函数" "多物多态性"等等
某些古老的编程语言就是支持这些语言特性的
但不知道为什么 竟然被淘汰了
c++也不知道为什么能活到现在
可能是范形的出现吧
可是上面的语言特性c++都不支持
但是我们无论何时都在有意或无意 直接或间接地实现着上述的语言特性
但是往往都是不尽人意的 
如果是语言上支持的话 就会方便很多了
就像以前有人在c上模以多态1样
无论怎样也不可能超过语言上支持多态 可能高手和菜鸟的区别就在于高手会在c++上模以这些语言特性
呵呵～反正我还不是高手
如果我是高手就不会连1份工作都没找到  
神啊~打救我吧
入正题
委托  在c++应该是叫函数指针吧
但是函数指针和成员函数指针是有区别的
特别是成员函数指针
我们最需要的就是这个
把成员函数指针的调用方式简化成普通函数指针的调用方式
其实就是实现1个范化的仿函数
loki中就有1个这样的范化仿函数
用起来就和普通函数指针1样
但它的实作就有点复杂
boost的范化仿函数用起来还不是很理想我这个仿函数当然也是范形的
不过实作并不复杂
来1段代码template
<
class R   = void,//返回值
class T1 = void,//第1个参数
class T2 = void,//第2个参数
class T3 = void,//...
class T4 = void,//...
class T5 = void //5个参数也够了吧
> 
class Delegate;
template
class Delegate//偏特化 
{
typedef R R;class FunctorImpl//和loki1样都是通过虚函数来调用委托的成员函数
{
public: 
virtual R operator()() = 0;
};struct bit12
{
         unsigned long _value[3];
};
bit12 value;
                               //这就是用来保存对象的指针                                                       
                               //成员函数指针还有看不到的虚函数列表
public:      //这个构造函数可能用点难了解=.=
template//范化构造函数//
inline Delegate(PtrObj p, MemFn memFn)//这是委托成员函数的构造函数 {
struct D : public FunctorImpl     //局部class继承自FunctorImpl
{
D(PtrObj p, MemFn memFn)//范化构造函数
:pObj(p)           //用的类型信息是从
,pMemFn(memFn)//Delegate构造函数传人
{
}PtrObj pObj;//局部class的数据
MemFn pMemFn;//对象指针和成员函数指针R operator()()//实现了基类的虚函数
{                   //调用委托的成员函数
return ((*pObj).*pMemFn)(); 
}
};assert(sizeof(D) == sizeof(bit12));
                                  //检测局部class大小和保存数据的大小是否1样D d(p,memFn);//实例化局部classvalue = *((bit12*)(void*)&d);
                                               //吧局部class的实例保存起来包括虚函数列表
                                               //这时派生类的型别已经不重要了,重要的是数据
}template
inline Delegate(const Fun fun)//这是委托普通函数的构造函数
{                                         //基本上和上面的构造韩数1样
struct D : public FunctorImpl
{
D(Fun fun)
:pObj(0)
,pFun(fun)
{
}void* pObj;
Fun pFun;R operator()()
{
return pFun(); 
}
};assert(sizeof(D) == sizeof(bit12));D d(fun);value = *((bit12*)(void*)&d);
}inline Delegate(Delegate& other)//copy构造函数
:value(other.value)
{
}
inline R operator()()
{
FunctorImpl* pf = (FunctorImpl*)(void*)&value;
return (*pf)();
}
                  //这就是把委托的函数调用的对方
                  //把保存起来的值转换到虚基类然后调用
                  //至于原来的型别就已经不重要了
                  //知道的就只有虚基类自己了
};
大家可能对构造函数里局部class很难理解
这个局部class里的数据类型是由范化构造函数的型别参数决定的
其实就和普通的template class 1样
Delegate的构造函数调用1次就会自动生成1个新的class
所有的实现细节都会保存在这个class
然后通过虚基类来调用这个隐形的class
呵呵～是不是还不能理解
可能是大家对范形不态了解
其实理解范形的难度并不比你当年学多态的难度要高
只是大家都把范形当作绿叶
再来1段代码
class c0
{
public:
void f()
{
cout << "call f()" << endl;
}
};void __f()
{
cout << "call __f()" << endl;
}
int _tmain(int argc, _TCHAR* argv[])
{c0 c;
Delegate dele(&c,c0::f);
dele();       //调用委托的成员函数Delegate __dele(__f);
__dele();       //调用普通的函数Delegate __copy(__dele);//调用copy构造函数
__copy();__copy = dele;//赋值__copy();
while(1);
return 0;
}
呵呵～用起来是不是和普通函数指针1样
第1次写这样的文章
希望大家多多指教
qq：4390121
还有两个群 
5341856(交流shader的群)
4364442(广东地区交流游戏制作的群)
大家有空来灌水