在這篇文章里面，我介紹一下如何自己實現一個閉包，方便進行C++的類函數回調。該閉包能夠接受任意類以及類成員做參數。


* 閉包概念
來源于大名鼎鼎的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.

就是說閉包綁定了一個函數以及該函數調用發生需要的所有參數。當閉包被調用的時候，相當于函數被調用，而且可以訪問綁定的參數。


* 第一步，能接受任意類型的類對象
這是第一個實現
<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>

看起來不錯，是吧:-)
但是還不能綁定參數呢。。我們來解決這個問題，讓他能綁定一個參數先。


* 第二步，能綁定一個任意類型參數
<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>

哈哈，很好！現在可以綁定參數羅～～
那怎么可以綁定兩個參數呢？嘿嘿，自己想吧～

現在這個使用方法我覺得很難看，既然調用方法都是統一的void
Run()，我們應該可以讓它使用起來更簡單. 而且如果我要把兩個不同的
closure傳給某個函數就做不到。
比如:
<code>
class MyClass {
?public:
? void PrintName(const string& name) { cout << name; }
};

class MyClass_2 {
?public:
? void PrintValue(int val) { cout << val; }
}

// 這個函數怎么寫才能讓兩個不同的closure都可以傳進來？
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;
};

// 實現支持一個參數的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_;
};

// 輔助函數
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>