在這篇文章里面，我介紹一下如何自己實現(xiàn)一個閉包，方便進(jìn)行C++的類函數(shù)回調(diào)。該閉包能夠接受任意類以及類成員做參數(shù)。
* 閉包概念
來源于大名鼎鼎的wikipedia:
In computer science, a closure is a function that is evaluated in an
environment containing one or more bound variables. When called, the function can access these variables.
就是說閉包綁定了一個函數(shù)以及該函數(shù)調(diào)用發(fā)生需要的所有參數(shù)。當(dāng)閉包被調(diào)用的時候，相當(dāng)于函數(shù)被調(diào)用，而且可以訪問綁定的參數(shù)
托福答案 * 第一步，能接受任意類型的類對象
這是第一個實現(xiàn)
<code>
template<typename T>
class Closure {
typedef void （T::Func）（）；
public:
Closure（T* obj, Func f）：
obj_（obj）， f_（f） {
}
void Run（） {
（obj_::*f_）（）；
}
private:
T *obj_;
Func *f_;
};
</code>
使用起來
<code>
class MyClass {
public:
void PrintName（） { cout 《 "MyClass"; }
};
MyClass obj;
Closure<MyClass> closure（obj, &MyClass::PrintName）；
closure.Run（）；
</code>
看起來不錯，是吧：-）
但是還不能綁定參數(shù)呢我們來解決這個問題，讓他能綁定一個參數(shù)先。
* 第二步，能綁定一個任意類型參數(shù)
<code>
template<typename T, typename Arg>
class Closure {
typedef void （T::Func）（Arg）；
public:
Closure（T* obj, Func f, Arg a）：
obj_（obj）， f_（f）， a_（a） {
}
void Run（） {
（obj_::*f_）（a_）；
}
private:
T *obj_;
Func *f_;
Arg a_;
};
</code>
使用方法
<code>
class MyClass {
public:
void PrintName（const string& name） { cout 《 name; }
};
MyClass obj;
Closure<MyClass, string> closure（obj, &MyClass::PrintName, "MyName"）；
closure.Run（）；
</code>
哈哈，很好！現(xiàn)在可以綁定參數(shù)羅~~
那怎么可以綁定兩個參數(shù)呢？嘿嘿，自己想吧~
現(xiàn)在這個使用方法我覺得很難看，既然調(diào)用方法都是統(tǒng)一的void
Run（），我們應(yīng)該可以讓它使用起來更簡單。 而且如果我要把兩個不同的
closure傳給某個函數(shù)就做不到。
比如：
<code>
class MyClass {
public:
void PrintName（const string& name） { cout 《 name; }
};
class MyClass_2 {
public:
void PrintValue（int val） { cout 《 val; }
}
// 這個函數(shù)怎么寫才能讓兩個不同的closure都可以傳進(jìn)來？
void func（？？？* closure） { closure->Run（）； }
MyClass obj;
Closure<MyClass, string> closure1（obj, &MyClass::PrintName, "MyName"）；
MyClass_2 obj2;
Closure<MyClass_2, int> closure2（obj, &MyClass::PrintValue, 11）；
closure.Run（）；
</code>
* 第三步，使用起來更簡單的Closure
<code>
// 基類；
class Closure {
public:
virtual void Run（） = 0;
};
// 實現(xiàn)支持一個參數(shù)的Closure;
template<typename T, typename Arg>
class OneArgClosure: public Closure {
typedef void （T::Func）（Arg）；
public:
Closure（T* obj, Func f, Arg a）：
obj_（obj）， f_（f）， a_（a） {
}
virtual void Run（） {
（obj_::*f_）（a_）；
}
private:
T *obj_;
Func *f_;
Arg a_;
};
// 輔助函數(shù)
Template<typename T, typename Arg>
Closure* NewClosure（（T* obj, Func f, Arg a） {
return OneArgClosure（obj, f, a）；
}
</code>
使用起來簡單多啦
<code>
class MyClass {
public:
void PrintName（const string& name） { cout 《 name; }
};
MyClass obj;
Closure* closure = NewClosure（obj, &MyClass::PrintName, "MyName"）；
closure->Run（）；
delete closure;
</code>