1. 程式人生 > >【C++11】新特性——std::function

【C++11】新特性——std::function

用過C#的人,一般都知道委託和事件。
如果沒有用過C#,我在這裡簡單解釋一下委託,如果用過了,下面可以skip。

委託是一個方法宣告,我們知道,在C語言中,可以通過函式指標表示一個地址的CALL方法,委託在C#中也差不多是幹這樣的工作。
但是委託有一些不同,主要的地方就是,在C++中,函式指標並不是“面向物件”的,比如,我們有一個類CTest,類中有一個成員方法foo,此時如果我們要通過函式指標的方式來呼叫foo的話,因為foo是類CTest的成員,我們需要CTest的例項this指標。

比方說:
  1. class CTest  
  2. {  
  3.     public:  
  4.         void foo(int i) {}  
  5. };  
它的成員函式指標應該這樣寫:
  1. void (CTest::*FuncFoo)(int);  
如果這個成員是const修飾的,則這樣:
  1. void (CTest::*FuncFoo)(intconst;  

呼叫怎麼辦呢?這樣:
  1. CTest* pThis = new...;  
  2. FuncFoo pThis_foo = &CTest::foo;  
  3. (pThis->*pThis_foo)(123);  
如果你這樣寫:
  1. pThis->*pThis_foo(123);  
是會出問題的,因為->*這個運算子的優先順序很低。。。。

如果CTest不是在HEAP上的,是在stack上的呢?
這樣:
  1. CTest pThis;  
  2. (pThis.*pThis_foo)(123);  

這些奇葩的語法,->*、.*這種神奇的運算子真是蛋疼。
而有時候我們又無法逃避,比如啟動執行緒的時候,我們一般從一個static函式通過這種sb的語法,把類this當作引數傳過去,然後跑過去類的成員函式。

但是在C#中,委託則是面向物件的,你可以用委託表示一個類例項的成員函式指標。
比如:
  1. namespace
     ConsoleApplication1  
  2. {  
  3.     publicdelegatevoid CallbackFunc(int i);  
  4.     //void (callback*)(int i);
  5.     class CNewTest  
  6.     {  
  7.         privatestaticreadonlystring _str = "this CNewTest.";  
  8.         publicvoid MemberCallback(int i)  
  9.         {  
  10.             System.Diagnostics.Debug.WriteLine(i.ToString());  
  11.             System.Diagnostics.Debug.WriteLine(_str);  
  12.         }  
  13.     }  
  14.     class Program  
  15.     {  
  16.         staticvoid StaticCallback(int i)  
  17.         {  
  18.             System.Diagnostics.Debug.WriteLine(i.ToString());  
  19.         }  
  20.         staticvoid Main(string[] args)  
  21.         {  
  22.             CallbackFunc StaticCbF = new CallbackFunc(StaticCallback);  
  23.             StaticCbF(123); //Call to static void StaticCallback(int i)
  24.             CNewTest c = new CNewTest();  
  25.             CallbackFunc MembCbF = new CallbackFunc(c.MemberCallback);  
  26.             MembCbF(1234); //Call to c->MemberCallback
  27.             Console.ReadKey();  
  28.         }  
  29.     }  
  30. }  
輸出:
123
1234
this CNewTest.

也就是,在C#中,只要方法適應委託宣告,那都可以call過去,C#為我們自動隱藏了this指標。
所以,就在C#中誕生了事件,一個提供者物件通過定義一個委託,然後把委託宣告為事件,此時其他監聽者物件就可以把這個事件跟自己的成員函式掛鉤上來,然後等待提供者在需要的時候呼叫這個委託,則呼叫到了成員函式,就是觸發了事件。

為什麼宣告為事件,直接暴露委託不是可以了麼?
這是一個邏輯問題,如果直接暴露委託,那訂閱者是可以主動觸發委託的,訂閱者可以是主動的,還“訂閱”個屁啊。
如果用事件,則訂閱者只能等待提供者來觸發委託,此時訂閱者,只能是“被動”的。

這個概念,用C++的來理解,也就是:
類A有一個public的ptr、ptr_this,此ptr儲存了一個成員函式指標,ptr_this儲存ptr的類例項。
類B把這個ptr改成他自己的,ptr_this改成它的this,適應這個成員函式指標的宣告。
類A在某些工作搞定後,檢查一下ptr != nullptr,然後call這個ptr,就呼叫到了類B的成員函式。

但是C++做這些有天然的不足,ptr不是nullptr倒是可以,但是可能類B早被delete了,但是儲存在你類A的ptr依然不是nullptr,你call直接掛,當然用C11的shared_ptr、weak_ptr這種東西,倒是也是一個解決方案,不過總的來說,就是不爽,這得多麻煩?
也就是C++,我們還是難以跳出手動管理記憶體這個圈子。
C#的GC自動管理則完全通殺這些問題。

還有一個就是,C#中,委託是一個多播的實現,比如:
  1. staticvoid Main(string[] args)  
  2. {  
  3.     //CallbackFunc StaticCbF = new CallbackFunc(StaticCallback);
  4.     //StaticCbF(123); //Call to static void StaticCallback(int i)
  5.     //CNewTest c = new CNewTest();
  6.     //CallbackFunc MembCbF = new CallbackFunc(c.MemberCallback);
  7.     //MembCbF(1234); //Call to c->MemberCallback
  8.     CallbackFunc cbF = new CallbackFunc(StaticCallback);  
  9.     CNewTest c = new CNewTest();  
  10.     cbF += c.MemberCallback;  
  11.     cbF(123);  
  12.     Console.ReadKey();  
  13. }  
輸出:
123
123
this CNewTest.

簡單的說,就是cbF這個玩意兒裡面,有一個泛型的List。。。。在Call的時候,是跑表來一個個call的,十分方便。
說白了,委託就是一個【方法的介面】,只要方法對就行,安全又舒服。
於是委託+事件這種多播實現,就能很好的做出一個觀察者模式。

那麼多弊端出來了,C11委員會也發現了這些問題,就加入了一個std::function,這個東西呢,說簡單了,它就是差不多用來實現委託的功能的(不是實現事件哦)。
還是回到上面那個C#寫的ConsoleApplication1,我們用std::function重來一遍。
(編譯環境為VS2013,Windows SDK。)

使用std::function前,需要包含#include <functional>。


我們準備一下函式:
  1. class CNewTest  
  2. {  
  3.     char m_str[128];  
  4. public:  
  5.     void MemberCallback(int i)  
  6.     {  
  7.         strcpy(m_str,"this CNewTest.\n");  
  8.         printf("%d\n",i);  
  9.         printf(m_str);  
  10.     }  
  11. };  
  12. void StaticCallback(int i)  
  13. {  
  14.     printf("%d\n",i);  
  15. }  

一個直接的函式,一個類成員函式。
首先我們來呼叫StaticCallback:
  1. int main()  
  2. {  
  3.     std::function<void (int)> fp = std::function<void (int)>(&StaticCallback);  
  4.     fp(123);  
  5.     getchar();  
  6.     return 0;  
  7. }  
輸出:123

這樣寫有點多啊,恩,我們是C++,有typedef。
  1. int main()  
  2. {  
  3.     typedef std::function<void (int)> declare_fp;  
  4.     declare_fp fp = declare_fp(&StaticCallback);  
  5.