boost源码剖析之：泛型函数指针类boost::function(rev#3)
boost源碼剖析之：泛型函數(shù)指針類boost::function(rev#3)
?
劉未鵬
C++的羅浮宮(http://blog.csdn.net/pongba)
?
Note:?并非新作，03年曾放在blog上，現(xiàn)在這個(gè)版本應(yīng)該是修改后的最終版本。
?
前奏
如你所知，boost庫是個(gè)特性完備，且具備工業(yè)強(qiáng)度的庫，眾多C++權(quán)威的參與使其達(dá)到了登峰造極的程度。尤其泛型的強(qiáng)大威力在其中被發(fā)揮得淋漓盡致，令人瞠目結(jié)舌。
?
然而弱水三千，我們只取一瓢飲。下面，我試圖從最單純的世界開始，一步一步帶領(lǐng)你進(jìn)入源碼的世界，去探究boost::function(下文簡(jiǎn)稱function)內(nèi)部的精微結(jié)構(gòu)。
?
通常?，在單純的情況下，對(duì)函數(shù)的調(diào)用簡(jiǎn)單而且直觀，像這樣：
?
int fun(int someVal);
??int main(){
????fun(10);
??}
?
然而你可能需要在某個(gè)時(shí)刻將函數(shù)指針保存下來，并在以后的另一個(gè)時(shí)刻調(diào)用它，像這樣：
?
??int fun(int);
??typedef int (*func_handle)(int);
??int main(){
????func_handle fh=fun;
????...??//do something
????fh(10);
??}
?
但是，如果fun形式為void fun(int)呢？如你所見，fun可能有無數(shù)種形式，如果對(duì)fun的每一個(gè)形式都typedef一個(gè)對(duì)應(yīng)的func_handle，則程序員會(huì)焦頭爛額，不勝其擾，代碼也可能變得臃腫和丑陋不堪，甚至如果fun是仿函數(shù)呢？
?
幸運(yùn)的是C++泛型可以使代碼變得優(yōu)雅精致，面對(duì)無數(shù)種的可能，泛型是最好的選擇。
?
因此，你只是需要一個(gè)能夠保存函數(shù)指針的泛型模板類(對(duì)應(yīng)于Command模式)，因?yàn)榉盒途幊逃幸粋€(gè)先天性的優(yōu)勢(shì)——可以借助編譯器的力量在編譯期根據(jù)用戶提供的類型信息化身千萬(實(shí)例化)，所以一個(gè)泛型的類可以有無限個(gè)實(shí)例，也就是說可以保存無限多種可能類型的函數(shù)或類似函數(shù)的東西(如仿函數(shù))。這個(gè)類(在boost庫中的類名為function)與函數(shù)指針相比應(yīng)該有以下一些優(yōu)勢(shì)：
?
1.?同一個(gè)function對(duì)象應(yīng)能夠接受與它形式兼容的所有函數(shù)和仿函數(shù),例如：
?
int f1(int); //?這是個(gè)函數(shù)，形式為?int(int)
short f2(double); //?這個(gè)函數(shù)形式為?short(double)
??struct functor //?這是個(gè)仿函數(shù)類，形式為int(int)
??{
????int operator()(int){}
??};
functor f3; //創(chuàng)建仿函數(shù)對(duì)象
?
boost::function<int(int)> func; //?能接受int(int)型的函數(shù)或仿函數(shù)
func = f1;??//?接受f1
func(10); //?調(diào)用f1(10)
func = f2;??//?也能接受short(double)型的f2
func(10); //?調(diào)用f2(10)
func = f3;??//?也能接受仿函數(shù)f3
func(10); //?調(diào)用f3(10)
?
2. function應(yīng)能夠和參數(shù)綁定以及其它function-construction庫協(xié)同工作。例如，function應(yīng)該也能夠接受std::bind1st返回的仿函數(shù)。這一點(diǎn)其實(shí)由第一點(diǎn)已經(jīng)有所保證。
?
3.?當(dāng)接受的一個(gè)空的仿函數(shù)對(duì)象被調(diào)用的時(shí)候function應(yīng)該有可預(yù)期的行為。
?
顯然，第一點(diǎn)是我們的重點(diǎn)，所謂形式兼容，就是說，對(duì)于：
?
R1 (T0,T1,T2,...,TN) => FunctionType1
R2 (P0,P1,P2,...,PN) => FunctionType2
?
兩種類型的函數(shù)（廣義），只要滿足：
?
R2能夠隱式轉(zhuǎn)換為R1
所有Ti都能夠隱式轉(zhuǎn)換為Pi (i取0,1,2,...)
?
那么就說，boost::function<FunctionType1>可以接受FunctionType2類型的函數(shù)(注意，反之不行)。支持這一論斷的理由是，只要Ti能夠隱式轉(zhuǎn)型為Pi，那么參數(shù)被轉(zhuǎn)發(fā)給真實(shí)的函數(shù)調(diào)用就是安全的，并且如果R2能夠隱式轉(zhuǎn)型為R1，那么返回真實(shí)函數(shù)調(diào)用所返回的值就是安全的。這里安全的含義是，C++類型系統(tǒng)假定隱式轉(zhuǎn)換不會(huì)丟失信息，或者編譯器至少會(huì)給出編譯警告。
?
后面你會(huì)看到，boost::function通過所謂的invoker非常巧妙地實(shí)現(xiàn)了這點(diǎn)，并且阻止了被形式不兼容的函數(shù)賦值的操作。
?
探險(xiǎn)
先看一個(gè)function的最簡(jiǎn)單的使用：
?
int g(int); //?為了讓代碼簡(jiǎn)單，假設(shè)g有定義，以后的代碼都會(huì)如此
function<int(int)> f(g);
f(0);
?
間奏——R(T1,T2,...)函數(shù)類型
雖然這個(gè)間奏未免早了點(diǎn)兒，但是為了讓你以后不會(huì)帶著迷惑，這是必要的。請(qǐng)保持耐心。
?
或許你會(huì)對(duì)模板參數(shù)int(int)感到陌生，其實(shí)它是個(gè)函數(shù)類型——函數(shù)g的確切類型就是int(int)，而我們通常所看到的函數(shù)指針類型int (*)(int)則是&g的類型。它們的區(qū)別與聯(lián)系在于：當(dāng)把g作為一個(gè)值進(jìn)行拷貝的時(shí)候（例如，按值傳參），其類型就會(huì)由int(int)退化為int(*)(int)，即從函數(shù)類型退化為函數(shù)指針類型——因?yàn)閺恼Z義上說，函數(shù)不能被“按值拷貝”，但身為函數(shù)指針的地址值則是可以被拷貝的。另一方面，如果g被綁定到引用，則其類型不會(huì)退化，仍保持函數(shù)類型。例如：
?
template<class T>
void test_func_type(T ft) //?按值傳遞，類型退化
{
//?故意引發(fā)編譯錯(cuò)誤，在錯(cuò)誤信息里看出ft的類型為退化后的函數(shù)指針類型
static_cast<int>(ft);
}
?
int g(int); // g的確切類型為int(int)
?
test_func_type(g);??// g的類型將會(huì)退化為函數(shù)指針類型
?
int (&ref_f)(int) = g; //?由于綁定到引用，類型并不退化
?
當(dāng)然，這樣的代碼不能通過編譯，因?yàn)閟tatic_cast顯然不會(huì)讓一個(gè)函數(shù)指針轉(zhuǎn)換為int，然而我們就是要它通不過編譯，這樣我們才能窺視到按值傳遞的參數(shù)ft的類型到底是什么，從編譯錯(cuò)誤中我們看出，ft的類型是int(*)(int)，也就是說，在按值傳遞的過程中，g的類型退化為函數(shù)指針類型，變得和&g的類型一樣了。而ref_t的類型則是引用，引用綁定則沒有引起類型退化。
?
請(qǐng)注意，函數(shù)類型乃是個(gè)極其特殊的類型，在大多數(shù)時(shí)候它都會(huì)退化為函數(shù)指針類型，以便滿足拷貝語義，只有面對(duì)引用綁定的時(shí)候，能夠維持原來的類型。當(dāng)然，對(duì)于boost::function，總是按值拷貝。
?
繼續(xù)旅程
function<int(int)>實(shí)際上進(jìn)行了模板偏特化，boost庫給function的類聲明為：
?
template<
typename Signature,??//函數(shù)類型
typename Allocator = ... //Allocator并非重點(diǎn)，故不作介紹
>?
class function;
?
事實(shí)上function類只是個(gè)薄薄的外覆（wrapper），真正起作用的是其偏特化版本。
?
對(duì)于function<R(T0)>形式，偏特化版本的function源碼像這樣(實(shí)際上在boost源代碼中你看不到模板參數(shù)T0的聲明，也看不到function1，它們被宏替換掉了，那些精巧的宏是為了減小可見的代碼量，至于它們的細(xì)節(jié)則又是一個(gè)世界，以下代碼可看作對(duì)將那些令人眼花繚亂的宏展開后所得到的代碼，具有更好的可讀性)：
?
摘自：”boost/function/function_template.hpp”
?
template<typename R,typename T0,typename Allocator>
class function<R(T0),Allocator> //?對(duì)R(T0)函數(shù)類型的偏特化版本
:public?function1<R,T0,Allocator> //?為R(T0)形式的函數(shù)準(zhǔn)備的基類
{
typedef?function1<R,T0,Allocator> base_type;
typedef function selftype;
?
struct?clear_type{}; //?馬上你會(huì)看到這個(gè)蹊蹺的類型定義的作用
?
public:
…
//?模板化的構(gòu)造函數(shù)，為了能夠接受形式兼容的仿函數(shù)對(duì)象。
//?這個(gè)構(gòu)造函數(shù)的作用在下面解釋
template<typename Functor>
??function(Functor f,
typename?enable_if<
?????????????(ice_not<(is_same<Functor, int>::value)>::value),
?????????????int
>::type = 0)
:base_type(f)
{}
?
//?這個(gè)構(gòu)造函數(shù)的作用見下文解釋
function(clear_type*) : base_type() {}
???
...
};
?
boost::enable_if
你一定對(duì)模板構(gòu)造函數(shù)中出現(xiàn)的那個(gè)冗長的enable_if<...>的作用心存疑惑，其實(shí)它的作用說穿了很簡(jiǎn)單，就是：當(dāng)用戶構(gòu)造：
?
function<int(int)> f(0);
?
的時(shí)候，將該（帶有enable_if的）構(gòu)造函數(shù)從重載決議的候選集中踢掉。使重載決議的結(jié)果為選中第三個(gè)構(gòu)造函數(shù)：
?
function(clear_type*):base_type(){}
?
從而進(jìn)行缺省構(gòu)造。
?
而說得冗長一點(diǎn)就是：當(dāng)f的類型——Functor——不是int時(shí)，該構(gòu)造函數(shù)就是“有效（enable）”的，會(huì)被重載決議選中。但如果用戶提供了一個(gè)0，用意是構(gòu)造一個(gè)空(null)的函數(shù)指針，那么該函數(shù)就會(huì)由于“SFINAE”原則而被從重載決議的候選函數(shù)中踢掉。為什么要這樣呢？因?yàn)樵摌?gòu)造函數(shù)負(fù)責(zé)把確切的f保存起來，它假定f并非0。那應(yīng)該選擇誰呢？第三個(gè)構(gòu)造函數(shù)！其參數(shù)類型是clear_type*，當(dāng)然，0可以被賦給任何指針，所以它被選出，執(zhí)行缺省的構(gòu)造行為。
?
基類?functionN
function的骨架就這些。也許你會(huì)問，function作為一個(gè)仿函數(shù)類，怎么沒有重載operator()——這可是身為仿函數(shù)的標(biāo)志啊！別急，function把這些煩人的任務(wù)都丟給了它的基類functionN，根據(jù)情況不同，N可能為0，1，2...，說具體一點(diǎn)就是：根據(jù)用戶使用function時(shí)給出的函數(shù)類型，function將會(huì)繼承自不同的基類——如果用戶給出的函數(shù)類型為“R()”形式的，即僅有一個(gè)參數(shù)，則function繼承自function0，而對(duì)于R(T0)形式的函數(shù)類型，則繼承自function1，依此類推。前面說過，function只是一層外覆，而所有的秘密都在其基類functionN中！
?
不知道你有沒有發(fā)現(xiàn)，function的骨架中也幾乎沒有用到函數(shù)類型的信息，事實(shí)上，它也將這些信息一股腦兒拋給了基類。在這過程中，混沌一團(tuán)的int(int)類型被拆解為兩個(gè)單獨(dú)的模板參數(shù)傳給基類:
?
template<typename R,typename T0,typename Allocator>
class function<R(T0),Allocator> // R(T0)整個(gè)為一類型
:public?function1<R,T0,Allocator> //?拆解為兩個(gè)模板參數(shù)R,T0傳給基類
?
好了，下面我們深入基類function1。真正豐富的寶藏在里面。
?
function1
function1的源代碼像這樣(與上面一樣，事實(shí)上有些代碼你是看不到的，為了不讓你迷惑，我給出的是將宏展開后得到的代碼):
?
摘自：”boost/function/function_template.hpp”
?
template<typename R,typename T0,class Allocator = ...>
class?function1
: public?function_base?// function_base負(fù)責(zé)管理內(nèi)存
{
...
public:
typedef R result_type;???//返回類型
typedef function1 self_type;
?
template<typename Functor>
function1(Functor const & f,
typename enable_if<...>::type = 0)
: function_base(), invoker(0)
{
this->assign_to(f);???//這兒真正進(jìn)行賦值，assign_to的代碼在下面列出
}
?
template<typename Functor>
void?assign_to(Functor f) //?所有的構(gòu)造函數(shù)都調(diào)用它！具有多個(gè)重載版本。
{
?????//?以一個(gè)get_function_tag萃取出Functor的類別(category)!
typedef typename detail::function::get_function_tag<Functor>::type
tag;
?????
??????//?根據(jù)不同類別的Functor采取不同的assign策略！
this->assign_to(f,?tag()); //?轉(zhuǎn)到真正做事情的assign_to版本，見下文。
}
?
...
result_type?operator()(T0?a0) const //?身為仿函數(shù)的標(biāo)志！
{
...
?
????//?這里進(jìn)行真正的函數(shù)調(diào)用，使用invoker，
// invoker是functionN的成員變量，在下面的assign_to中被賦值。
// functor為實(shí)際被調(diào)用的函數(shù)或仿函數(shù)，a0當(dāng)然是其參數(shù)。
????internal_result_type?result =?invoker(function_base::functor,?a0);
???
//?將得到的結(jié)果cast至最終返回出去的類型
return static_cast<result_type>(result);
}
?
其中值得注意的是：
get_function_tag<>能萃取出Functor的類別(category)，有下面幾種類別
?
struct function_ptr_tag {}; //?函數(shù)指針
struct function_obj_tag {}; //?仿函數(shù)對(duì)象
struct member_ptr_tag {}; //?成員函數(shù)
struct function_obj_ref_tag {}; //?以ref(obj)加以封裝的類別，具有引用語義
struct stateless_function_obj_tag {}; //?無狀態(tài)函數(shù)對(duì)象
?
此外，滿足以下所有條件：
?
has_trivial_constructor
has_trivial_copy
has_trivial_destructor
is_empty
?
的仿函數(shù)對(duì)象稱為stateless的。
?
對(duì)于不同的函數(shù)類別，assign_to有各個(gè)不同的重載版本，如下：
?
template<typename FunctionPtr> //?如果是函數(shù)指針就調(diào)用這個(gè)版本
void assign_to(FunctionPtr f,?function_ptr_tag) //?這個(gè)版本針對(duì)函數(shù)指針
{
clear();
???
??if(f){
????typedef
typename ...::get_function_invoker1<
??????????????????FunctionPtr,R,T0>::type
invoker_type; //?萃取相應(yīng)的invoker
???
invoker = &invoker_type::invoke; //?invoke是一個(gè)static成員函數(shù)
???
function_base::manager?= //?管理策略，一個(gè)函數(shù)指針
??????&...::functor_manager<FunctionPtr, Allocator>::manage;
?
//?交給function的函數(shù)指針或仿函數(shù)對(duì)象指針最終在這兒保存
function_base::functor?=
function_base::manager(
...::make_any_pointer((void (*)())(f)),
????????...::clone_functor_tag); //?拷貝一份
}
}
??...
?
??//?any_pointer在下文解釋
typedef internal_result_type(*invoker_type)(...::any_pointer, T0);
?
invoker_type invoker; //?重要成員，負(fù)責(zé)調(diào)用函數(shù)！
?
}; // function1類定義的結(jié)尾
?
function的底層存儲(chǔ)機(jī)制
請(qǐng)將目光轉(zhuǎn)向上面的代碼段末尾的assign_to函數(shù)中，其中有兩行代碼分別對(duì)function_base里的manager和functor成員賦值。這兩行代碼肩負(fù)了保存各種函數(shù)指針的任務(wù)。
?
manager是一個(gè)函數(shù)指針，它所指向的函數(shù)代表管理策略，例如，對(duì)于函數(shù)指針，僅僅作一次賦值，就保存完畢了，但是對(duì)于仿函數(shù)，得額外分配一次內(nèi)存，然后將仿函數(shù)拷貝到分配的內(nèi)存中，這才完成了保存的任務(wù)。這些策略根據(jù)函數(shù)的類別而定，上面代碼中的assign_to函數(shù)是針對(duì)函數(shù)指針類別的重載版本，所以manager的策略是不作任何內(nèi)存分配，直接返回被轉(zhuǎn)型為“void(*)()”（利于在底層以統(tǒng)一的形式保存）的函數(shù)指針就行了，這從代碼中可以看出。
?
需要說明的是，對(duì)于函數(shù)指針，function_base并不知道也不關(guān)心它要保存的函數(shù)指針是什么確切的類型，只要是函數(shù)指針就行，因?yàn)樗倳?huì)把該函數(shù)指針f轉(zhuǎn)型為“void (*)()”類型，然后保存在functor成員中，functor成員是一個(gè)union類型:
?
union?any_pointer
{
????//?任意仿函數(shù)對(duì)象指針都可以用static_cast轉(zhuǎn)型為void*型
void* obj_ptr;
???
????//?為const仿函數(shù)準(zhǔn)備的
const void* const_obj_ptr;
???
//?任意函數(shù)指針都可以用reinterpret_cast轉(zhuǎn)型為void(*)()型
void (*func_ptr)();
?
char data[1];
};
?
這個(gè)any_pointer可以通過安全轉(zhuǎn)型保存所有形式的仿函數(shù)和函數(shù)指針，承載在底層保存數(shù)據(jù)的任務(wù)
?
function的調(diào)用機(jī)制——invoker
我們把目光轉(zhuǎn)到function1的定義的最底部，那兒定義了它最重要的成員invoker，它是一個(gè)函數(shù)指針，所指向的函數(shù)就是function的調(diào)用機(jī)制所在，invoker的類型為：
?
typedef internal_result_type (*invoker_type)(any_pointer,T0);
?
前面已經(jīng)說過，any_pointer是個(gè)union，可以保存任何類型的函數(shù)指針或函數(shù)對(duì)象，里面保存的是用戶給出的函數(shù)或仿函數(shù)，T0則是保存于any_pointer中的函數(shù)的參數(shù)類型（若有兩個(gè)參數(shù)則是T1,T2）。這也就是說，invoker負(fù)責(zé)調(diào)用保存在any_pointer中的函數(shù)或仿函數(shù)。
?
那么，invoker這個(gè)函數(shù)指針到底指向什么函數(shù)呢——也就是說，在什么時(shí)候invoker被賦值了呢？我們?cè)俅伟涯抗廪D(zhuǎn)向assign_to函數(shù)，其中有一行對(duì)invoker成員賦值的語句，從這行語句出發(fā)我們可以揭開invoker的全部奧秘：
?
invoker = &invoker_type::invoke; // invoke是一個(gè)static成員函數(shù)
?
請(qǐng)不要把這個(gè)invoker_type和上面那個(gè)函數(shù)指針類型invoker_type混淆起來，這個(gè)invoker_type是位于assign_to函數(shù)中的一個(gè)局部的typedef，所以隱藏了后者（即類作用域中的那個(gè)invoker_type——invoker成員的類型）。往上一行，你就看到這個(gè)局部類型invoker_type的定義了：
?
typedef typename?get_function_invoker1<
??????????FunctionPtr,R,T0>::type?invoker_type;
?
get_function_invoker1又是何物？很顯然，這是個(gè)traits，其內(nèi)嵌的::type會(huì)根據(jù)不同的模板參數(shù)表現(xiàn)為不同的類型，在本例中，::type的類型將會(huì)被推導(dǎo)為
?
function_invoker1<int(*)(int),int,int>
?
而function_invoker1是個(gè)類模板，其定義為：
?
template<
typename FunctionPtr,
typename R，typename T0
> //?注意這里的模板參數(shù)，后面會(huì)解釋
struct function_invoker1
{
static R?invoke(any_pointer function_ptr, T0 a0)
{
FunctionPtr?f?=
reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
return?f(a0);
}
};
?
所以對(duì)invoker的賦值最終相當(dāng)于：
?
invoker = &function_invoker1<int(*)(int),int,int>::invoke;
?
而從上面的function_invoker1的定義可以看出，
function_invoker1<int(*)(int),int,int>::invoke是一個(gè)靜態(tài)成員函數(shù)，它被實(shí)例化后相當(dāng)于：
?
static int?invoke(any_pointer function_ptr, int a0)
{
//?先轉(zhuǎn)型，再調(diào)用，注意，這一行語句還有一個(gè)額外的作用，在后面解釋
int (*f)(int) = reinterpret_cast<int(*)(int)>(function_ptr.func_ptr);
?
//?因?yàn)閒指向的是用戶保存在該function中的函數(shù)或仿函數(shù)，
//?所以這一行語句進(jìn)行了最終真正的調(diào)用！
return?f(a0);
}
?
我們可以看出，在invoke函數(shù)中，真正的調(diào)用現(xiàn)身了。
?
此外，如果用戶當(dāng)初給出的是仿函數(shù)而不是函數(shù)指針，則有function_obj_invoker1與它對(duì)應(yīng)，后者也是一個(gè)類似的模板，它的invoke靜態(tài)成員函數(shù)的形式也是：
?
static R invoke(any_pointer?function_obj_ptr, T0 a0);
?
其中function_obj_ptr是指向仿函數(shù)的指針，所以這個(gè)版本的invoke中對(duì)它的調(diào)用語句是這樣的：
?
FunctionObj* f =?(FunctionObj*)(function_obj_ptr.obj_ptr);
return?(*f)(a0); //?調(diào)用用戶當(dāng)初給出的仿函數(shù)
?
最后一種可能：如果接受的是成員函數(shù)怎么辦呢？簡(jiǎn)單的答案是：boost::function并沒有為成員函數(shù)作任何特殊準(zhǔn)備！理由也很簡(jiǎn)單，boost::function只要先將成員函數(shù)封裝為仿函數(shù)，然后將其作為一般的仿函數(shù)對(duì)待就行了，具體代碼就不列了，STL中有一個(gè)函數(shù)模板std::mem_fun就是用于封裝成員函數(shù)指針的，它返回的是一個(gè)仿函數(shù)。boost中也對(duì)該函數(shù)模板做了擴(kuò)充，使它可以對(duì)付任意多個(gè)參數(shù)的成員函數(shù)。
?
做一個(gè)，送一個(gè)——invoker的額外好處
我們注意到function的構(gòu)造和賦值函數(shù)及其基類的構(gòu)造和賦值函數(shù)都是模板函數(shù)，這是因?yàn)橛脩艨赡芴峁┖瘮?shù)也可能提供仿函數(shù)，但最關(guān)鍵的還是，functiont提供一種能力：對(duì)于function<double(int)>類型的泛型函數(shù)指針，用戶可以給它一個(gè)int(int)類型的函數(shù)——是的，這是可行且安全的，因?yàn)槠浞祷刂殿愋?strong>int可以安全的轉(zhuǎn)型為double，而對(duì)于這種類型兼容性的檢查就在上面分析的invoke靜態(tài)成員函數(shù)中，這就是我們要說的額外好處——如果類型兼容，那么invoke函數(shù)就能正常編譯通過，但如果用戶給出類型不兼容的函數(shù)，就會(huì)得到一個(gè)錯(cuò)誤，這個(gè)錯(cuò)誤是在編譯器實(shí)例化invoke函數(shù)代碼的時(shí)候給出的，例如，用戶如果這樣寫：
?
//?聲明一個(gè)雙參的函數(shù)f
RT1 f(P1,P2);
?
??//?單參的function實(shí)例
function<RT(P)> f_ptr;
?
f_ptr = &f; //?類型不兼容，錯(cuò)誤！
?
這就會(huì)導(dǎo)致編譯錯(cuò)誤，錯(cuò)誤發(fā)生在invoke靜態(tài)成員函數(shù)中。下面我就為你解釋為什么。
?
我想你對(duì)function_invoker1的三個(gè)模板參數(shù)仍然心存疑惑，我們?cè)僖淮蝸砘仡櫼幌缕渎暶?#xff1a;
?
template<
typename FunctionPtr,
typename R，typename T0>
struct function_invoker1
?
我們還得把目光投向assign_to模板函數(shù)，其中使用function_invoker1的時(shí)候是這樣的：
?
typedef typename ...::get_function_invoker1<
?????????????????????????FunctionPtr,R,T0>::type invoker_type;
?
FunctionPtr，R，T0三個(gè)模板參數(shù)將會(huì)被原封不動(dòng)的傳給function_invoker1，那么對(duì)于我們上面的錯(cuò)誤示例，這三個(gè)模板參數(shù)各是什么呢？
?
首先，我們很容易看出，FunctionPtr就是assign_to模板函數(shù)的模板參數(shù)，也就是用戶傳遞的函數(shù)或仿函數(shù)的類型，在我們的錯(cuò)誤示例中，函數(shù)f的類型為RT1(P1,P2)，所以
?
FunctionPtr?=?RT1(*)(P1,P2)
?
而R,T0則是用戶在實(shí)例化function模板時(shí)給出的模板參數(shù)，我們寫的是function<RT(P)>，于是:
?
R?=?RT
T0?=?P
?
所以，對(duì)于我們的錯(cuò)誤示例，invoker_type的類型為：
?
function_invoker1<?RT1(*)(P1,P2),RT,P>
?
對(duì)于這樣一個(gè)function_invoker1，其內(nèi)部的invoke靜態(tài)成員函數(shù)被實(shí)例化為：
?
static RT invoke(any_pointer function_ptr,P a0)
{
??//?注意f的類型
RT1 (*f)(P1,P2) = reinterpret_cast<RT1(*)(P1,P2)>(function_ptr.func_ptr);
???
return f(a0); //錯(cuò)啦！瞧瞧f的類型，f能接受一個(gè)P類型的參數(shù)嗎？編譯器在此打住。
}
?
看看最后一行語句，所有的檢查都在那里了——我們最終把檢查“委托”給了C++底層的類型系統(tǒng)。
?
很精妙不是嗎？雖然在模板形式的assign_to函數(shù)中，看起來我們并不關(guān)心到底用戶給的參數(shù)是何類型，看起來用戶可以把任何函數(shù)或仿函數(shù)塞過來，但是一旦下面觸及invoker的賦值，就得實(shí)例化invoke靜態(tài)成員函數(shù)，其中的：
?
return f(a0);
?
一下就把問題暴露出來了！這種把類型檢查延遲到最后，不得不進(jìn)行的時(shí)候，由C++底層的類型系統(tǒng)來負(fù)責(zé)檢查的手法的確很奇妙——看起來我們沒有在assign_to函數(shù)中及時(shí)利用類型信息進(jìn)行類型檢查，但是我們卻并沒有喪失任何類型安全性，一切最終都逃不過C++底層的類型系統(tǒng)的考驗(yàn)！
?
function如何對(duì)待成員函數(shù)
對(duì)于成員函數(shù)，assign_to的重載版本只有一行：
?
this->assign_to(mem_fn(f));
?
mem_fun(f)返回一個(gè)仿函數(shù)，它封裝了成員函數(shù)f，之后一切皆與仿函數(shù)無異。
?
關(guān)于mem_fun的細(xì)節(jié)，這里就不多說了，大家可以參考STL中的實(shí)現(xiàn)，相信很容易看懂，這里只簡(jiǎn)單的提醒一下，成員函數(shù)封裝的效果是這樣的：
?
R (C::*)(T0,T1,...) => R (*)(C*,T0,T1,...)?或?R (*)(C&,T0,T1,...)
?
safe_bool慣用手法
如你所知，對(duì)于函數(shù)指針fptr，我們可以這樣測(cè)試它：if(fptr) ...，所以function也應(yīng)該提供這一特性，然而如果直接重載operator bool()則會(huì)導(dǎo)致下面的代碼成為合法的:
?
function<int(int)> f;
int?b=f;
?
這顯然不妥，所以function用另一個(gè)巧妙的手法替代它，既所謂的safe_bool慣用手法，這在function定義內(nèi)部的源碼如下：
?
struct dummy { void nonnull(){};};
typedef void (dummy::*safe_bool)(); //?確保safebool不能轉(zhuǎn)型為任何其它類型！
operator?safe_bool?() const
{ return (this->empty())? 0 : &dummy::nonnull; }
?
這樣，當(dāng)你寫if(f)的時(shí)候，編譯器會(huì)找到operator safe_bool()，從而將f轉(zhuǎn)型為safe_bool，這是個(gè)指針類型，if語句會(huì)正確判定它是否為空指針。而當(dāng)你試圖把f賦給其它整型變量的時(shí)候則會(huì)遭到編譯期的拒絕——因?yàn)閟afe_bool是一個(gè)成員指針類型，無法向其它整型轉(zhuǎn)換。
?
get_function_tag
get_function_tag用于萃取出函數(shù)所屬類別(category)，各個(gè)類別在源代碼中已經(jīng)列出，至于它到底是如何萃取的，這與本文關(guān)系不是很大，有一點(diǎn)需要提醒一下：函數(shù)指針類型也是指針類型，這聽起來完全是句廢話，但是考慮這樣的代碼：
?
template<typename T> struct is_pointer{enum{value=0};};
template<typename T> struct is_pointer<T*>{enum{value=1};};
std::cout<<is_pointer<int(*)(int)>::value; //?這將輸出?1
?
也就是說int(*)(int)可以與T*形式匹配，匹配時(shí)T為int(int)。
?
最后一些細(xì)節(jié)
1.?我沒有給出function_base的源代碼，實(shí)際上那很簡(jiǎn)單，它最主要的成員就是一個(gè)union any_pointer型的數(shù)據(jù)成員
?
????//?用于統(tǒng)一保存函數(shù)指針及仿函數(shù)對(duì)象指針
detail::function::any_pointer functor;?
?
2.?我沒有給出functor_manager的信息，實(shí)際上它與function的實(shí)現(xiàn)沒有太大關(guān)系，它負(fù)責(zé)copy和delete函數(shù)對(duì)象，如果必要的話。所以我將它略去，它的源碼在”boost/function/function_base.hpp”里。
?
3.?我給出的源代碼是將宏展開后的版本，實(shí)際的代碼中充斥著讓人眼花繚亂的宏，關(guān)于那些宏則又是一個(gè)奇妙的世界。boost庫通過那些宏省去了許多可見代碼量。隨著函數(shù)參數(shù)的不同，那些宏會(huì)擴(kuò)展出function2,function3...各個(gè)版本。而本文只研究了int(int)型的情況，其它只是參數(shù)數(shù)目的改變而已。經(jīng)過宏的擴(kuò)展，function的偏特化版本將有:
?
template<typename R,typename Allocator>
class function<R(),Allocator>:public function0<R,Allocator>
{...};
template<typename R,typename T0,typename Allocator>
class function<R(T0),Allocator>:public function1<R,T0,Allocator>
{...};
template<typename R,typename T0,typename T1,typename Allocator>
class function<R(T0,T1),Allocator>:public function2<R,T0,T1,Allocator>
{...};
...
?
等更多版本，一共有BOOST_FUNCTION_MAX_ARGS+1個(gè)版本，BOOST_FUNCTION_MAX_ARGS為一個(gè)宏，控制最多能夠接受有多少個(gè)參數(shù)的函數(shù)及仿函數(shù)對(duì)象，你可以重新定義這個(gè)宏為一個(gè)新值，以控制function所能支持的函數(shù)參數(shù)個(gè)數(shù)的最大值。其中的function0,function1,function2等名字也由宏擴(kuò)展出。
總結(jié)
以上是生活随笔為你收集整理的boost源码剖析之：泛型函数指针类boost::function(rev#3)的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： boost源码剖析之：Tuple Typ
- 下一篇： boost源码剖析之：多重回调机制sig