以下文章來源于CppMore，作者里繆

引言

很多時候，選擇單一，事情做來不會有多少阻力，選擇太多 ，倒是舉棋難定了。

C++ 復雜性的一方面就體現在選擇太多，對于同一種需求，可能存在數十種不同的方式都能夠解決，此時每種方式的優劣便是學習的難點。

std::function,函數指針, std::bind, Lambda 就是這樣的一些組件，使用頻率不低，差異細微，許多人不清楚何時使用何種方式，常常誤用，致使程序性能出現瓶頸。

本文全面地對比了這些組件間的細微差異，并評估不同方式的性能優劣，提出使用建議及一些實踐經驗。

首先要明確誰與誰對比，理清可替代對象，這樣對比起來才有意義。

std::function 的對比對象是函數指針，它們主要是為了支持函數的延遲調用；std::bind的對比對象是Lambda 和std::bind_front，主要是為了支持參數化綁定。

本文會全面對比這些方式的運行時間、編譯時間、內存占用和指令讀取總數。

舊事

函數若是不想被立即執行，在 C 及 C++11 以前存在許多方式，函數指針是最普遍的一種方式。看個例子：

voidfoo(intx){
std::cout<

	

	通過函數指針實現了函數的延遲調用，這在回調函數、事件處理、惰性計算等場景下被廣泛使用。C++11 之前，提供了仿函數來代替函數指針，于是上述示例可以等價寫成：

	
structfunctor{
voidoperator()(intx)const{
std::cout<

	

	相比函數指針，仿函數具有更好的靈活性和安全性，它可以持有狀態，可以有成員函數和成員變量，并且更加容易被編譯器優化。而函數指針涉及間接調用，編譯器不會對其進行內聯優化，還有可能出現類型轉換錯誤。

	由于函數指針無法持有狀態，C 里面一般會增加一個狀態參數來捕獲狀態，例如：

	
typedefint(*add_pf)(void*,int);

intadd_with_state(void*state,intx){
intincrement=*(int*)state;
returnx+increment;
}

intbar(add_pffunc,void*state,intvalue){
returnfunc(state,value);//delayedinvocation
}

intmain(){
intincrement=5;
add_pfadd=add_with_state;
returnbar(add,&increment,10);//return15
}


	

	仿函數則稍微簡單一點，等價寫法為：

	
classadd_functor{
intincrement;
public:
add_functor(intinc):increment(inc){}
intoperator()(intx)const{
returnx+increment;
}
};

intbar(constadd_functor&func,intvalue){
returnfunc(value);//delayedinvocation
}

intmain(){
add_functoradd(5);
returnbar(add,10);//return15
}


	

	相較之下，仿函數捕獲狀態方便很多，語法也更加清晰簡潔。

	早期 C++ 還提供 std::bind1st 和 std::bind2nd 來綁定函數，以下是一個例子：

	
intadd(intx,inty){
returnx+y;
}

intmain(){
autobound_func=std::bind1st(std::ptr_fun(add),5);
returnbound_func(10);//return15
}


	

	不過如今都已廢棄，std::bind1st 被 std::bind 代碼，std::ptr_fun 被 std::function 代替。

	舊事且過，來看新的方法。

	std::function vs.Function pointer

	std::function 是 C++11 對于可調用體的高度抽象組件，不僅能夠持有普通函數和成員函數，還能夠持有仿函數、Lambda 和其他類型的可調用體。

	一個組件的抽象層次越高，考慮的越周全，額外的工作也就越多，開銷也會更大。

	下面通過一個簡單的例子，對比一下 std::function 和函數指針的生成代碼。

	
////////////////////////////////
//functionpointer
intadd(intx,inty){
returnx+y;
}

intbar(int(*func)(int,int),intx,inty){
returnfunc(x,y);
}

intmain(){
returnbar(add,5,10);//return15
}

////////////////////////////////
//std::function
intadd(intx,inty){
returnx+y;
}

intbar(std::functionfunc,intx,inty){
returnfunc(x,y);
}

intmain(){
returnbar(add,5,10);//return15
}


	

	在 GCC 13.2 最高級別的優化下，函數指針（ https://godbolt.org/z/vno8WaYTK ）生成的匯編代碼只有 11 行，而std::function （ https://godbolt.org/z/W71bWo3qj ）生成的卻有 60 行，差異巨大。

	實際 Benchmarks 一下，測試代碼為：

	
intadd(intx,inty){
returnx+y;
}

intbar_function_ptr(int(*func)(int,int),intx,inty){
returnfunc(x,y);
}

intbar_function(std::functionfunc,intx,inty){
returnfunc(x,y);
}

staticvoidfunction_ptr_bench(benchmark::State&state){
for(auto_:state){
intresult=bar_function_ptr(add,5,10);
benchmark::DoNotOptimize(result);
}
}
BENCHMARK(function_ptr_bench);

staticvoidfunction_bench(benchmark::State&state){
for(auto_:state){
intresult=bar_function(add,5,10);
benchmark::DoNotOptimize(result);
}
}
BENCHMARK(function_bench);


	

	結果不出所料，std::function 的運行開銷要遠遠大于函數指針。

	

	func-ptr-vs-function-benchmarks

	既然函數指針效率這么高，那還要 std::function 干嘛？

	除了舊事一節提到的關于函數指針的缺點，還有一個很大的不同在于一致性，std::function 能持有普通函數、成員函數、仿函數、Lambda 等等可調用體，靈活性突出，函數指針可沒有這個能力，是以適用性更低。

	請注意，盡管本節的對比結果表明函數指針效率更高，但卻并非是說推薦使用函數指針。

	std::bindvs. std::bind_front vs. Lambda vs.Function pointer

	std::bind 和 Lambda 都是 C++11 入的標準，然而，它們的功能重疊性很高，Lambda 幾乎可以完全替代 std::bind。

	std::bind_front則是C++20 用來替代std::bind的新特性，其靈活性和便捷性更好。

	本篇的核心是對比性能，關于它們之間區別的文章已指不勝屈，只是缺少性能分析方面的文章，故這里不會贅述已有內容。

	先來測試一下基本性能，測試例子如下：

	
#include
#include

intadd(intx,inty){
returnx+y;
}

typedefint(*pf)(int,int);

staticvoidfunc_ptr(benchmark::State&state){
intval=42;
pfadd_func=add;

for(auto_:state){
intresult=add_func(val,10);
benchmark::DoNotOptimize(result);
}
}
BENCHMARK(func_ptr);

staticvoidlambda(benchmark::State&state){
intval=42;
constautolam=[val](inty){
returnval+y;
};

for(auto_:state){
intresult=lam(10);
benchmark::DoNotOptimize(result);
}
}
BENCHMARK(lambda);

staticvoidbind(benchmark::State&state){
intval=42;
constautobind=std::bind(add,val,std::_1);
for(auto_:state){
intresult=bind(10);
benchmark::DoNotOptimize(result);
}
}
BENCHMARK(bind);

staticvoidbind_front(benchmark::State&state){
intval=42;
constautobind=std::bind_front(add,val);
for(auto_:state){
intresult=bind(10);
benchmark::DoNotOptimize(result);
}
}
BENCHMARK(bind_front);


	

	編譯器 GCC 13.2，不開優化，對比結果如下圖所示。

	

	可見，在設計上，Lambda 并不會比函數指針更慢，而 std::bind 卻將近慢了二十倍，std::bind_front 則比 std::bind 效率高許多，只慢了近十倍。

	注意這是在未開優化的情況下，事實上，如今的編譯器優化能力很強，示例相對過于簡單，優化后的效率是一樣的。但若是換成早期的編譯器，或是更加復雜的例子，效率和未開優化的情況基本是一致的。

	可以換一種編譯器，并降低其版本來觀察不同優化級別下的表現。編譯器切換為 Clang 10.0。

	O0 級別優化，對比結果如下圖所示。

	

	O1 級別優化，對比結果如下圖所示。

	

	O2 級別優化效果，結果如下圖所示。

	

	到這個優化級別，四種方式的性能已經持平。

	雖說不同編譯器的數值有所差異，但對比結果的整體趨勢基本一致。這個結果表明 std::bind 的確是性能殺手，應該優先使用 Lambda 或 std::bind_front 代替。

	Lambda vs.Functor

	Lambda 就是一個可以攜帶狀態的函數。

	其實現是一個含有 operator() 重載的匿名類，捕獲的參數作為匿名類的數據成員直接初始化。Lambda 使用時調用的便是這個重載的 operator()，返回的類型就是匿名類的類型，稱為 closure type。

	Lambda 就是為簡化仿函數（即函數對象）而來，無需在其他地方創建一個仿函數，直接原地構造。因此，它們的性能基本是一致的。

	加上以下測試代碼，和前面的 Lambda 代碼進行對比，驗證結果。

	
structFunctor{
intx;
autooperator()(inty)const{
returnx+y;
}
};

staticvoidfunctor(benchmark::State&state){
intval=42;
Functorfunctor(val);
for(auto_:state){
intresult=functor(10);
benchmark::DoNotOptimize(result);
}
}
BENCHMARK(functor);


	

	對比結果如下圖所示。

	

	結果表明結論正確。

	Lambda vs std::function

	Lambda 和 std::function得分兩種情況進行對比，一種是無需存儲可調用體，一種是需要存儲可調用體。

	先看第一種情況，測試代碼為：

	
intcallable_with_lambda(autofunc){
returnfunc(1,2);
}

intcallable_with_funtional(std::functionfunc){
returnfunc(1,2);
}

staticvoidpass_callable_with_lambda(benchmark::State&state){
for(auto_:state){
intresult=callable_with_lambda([](inta,intb){
returna+b;
});
benchmark::DoNotOptimize(result);
}
}
BENCHMARK(pass_callable_with_lambda);

staticvoidpass_callable_with_funtional(benchmark::State&state){
for(auto_:state){
intresult=callable_with_funtional([](inta,intb){
returna+b;
});
benchmark::DoNotOptimize(result);
}
}
BENCHMARK(pass_callable_with_funtional);


	

	測試環境依舊是 GCC 13.2，不開優化。對比結果如下圖。

	

	由此可知，Lambda 的開銷要比 std::function 小很多，應該優先使用泛型 Lambda 傳遞可調用體。

	再來看第二種情況，這種情況需要存儲可調用體，然而 Lambda 為 Closure type，只有使用 auto 或 decltype()才能推導出具體類型，它是無法存儲的。

	此時，你只能使用std::function 或函數指針。具體使用哪種方式，便需要在性能、便捷性、靈活性等方面作出取舍。若是傾向于最大的便捷性和靈活性，前者是更好的選擇；若是追求最大化性能，函數指針則是更好的方式。但需注意，若是選擇函數指針，調用者將無法再使用 Lambda 和std::bind等常見方式傳遞參數。

	Lambda vs.Function Pointer

	對比內容前文已涉，本節作為補充。

	Lambda 是可以隱式轉換為函數指針的，只需將形式寫成 +[]{}（注意不能捕獲狀態）。其性能與函數指針無異，這也是 Lambda 被廣泛使用的原因之一。Lambda 也可以攜帶狀態，并和 std::invocable Concept 配合起來接受可調用對象，集靈活性和高性能于一身。

	函數指針涉及間接調用，無法被編譯器優化，是以既無法內聯，也無法重新排序。它可能指向不同的函數，編譯器無法優化這些調用的具體細節，必須按照特定的調用約定進行處理。而 Lambda 在編譯時就可知道具體實現，編譯器可以直接生成高效的調用代碼，無需遵循通用的調用約定，這將帶來巨大的優化空間。

	此外，只要滿足 constexpr function 的條件，Lambda 會隱式 constexpr，因此可以在編譯期評估。

	編譯時間、內存占用、指令讀取：std::bind vs. std::bind_front vs. Lambda

	前文只是對比了這些方式在運行時間方面的性能，本節再對比編譯時間和內存占用。

	對比示例，代碼如下：

	
//bind.cpp
//////////////////////////////
#include
#include

intadd(intx,inty){
//std::cout<
#include

intadd(intx,inty){
//std::cout<
#include

intadd(intx,inty){
//std::cout<

	

	首先，來看編譯時間和內存占用情況。如下圖所示。

	

	可以看到，Lambda 消耗的時間最短，只有 1.27 秒，Bind 消耗的時間最多，1.34 秒；Lambda 的最大常駐內存大小為 96640KB，Bind Front 為 98436KB，而 Bind 是 100100KB。

	其次，再來對比一下它們的指令讀取情況。如下圖。

	

	其中，Lambda 運行期間指令總共讀取了32,265,989 次，Bind 是 390,268,192 次，而 Bind Front 是 262,267,908 次。可見，Lambda 比其他兩種方式的指令讀取次數少了一個數量級，Bind Front 較 Bind 也減少了非常多次。

	最后，不難得出，無論是在運行時間，還是編譯時間、內存占用和指令讀取方面，Lambda 的性能都是最好的，其次是 Bind Front，最后是 Bind。

	總結

	本文全面對比了 Lambda、std::bind、std::bind_front、std::function 和函數指針的性能，針對不同場景分析不同方式的優劣，以能夠根據場景靈活選擇適當的實現方式。

	Lambda 的性能（運行時間、編譯時間、內存占用、指令讀取總數）最好，和函數指針基本持平，其次是 std::bind_front，最后是 std::bind。std::bind 是失敗的設計，任何時候，都要優先使用 Lambda 或 std::bind_front。

	當不需要具體的可調用對象類型時，使用模板和 Lambda 的方式要優于 std::function，其保留了靈活性和高性能；當需要具體的類型時，std::function 能夠提供最大的靈活性和便捷性，此時若想追求最大化性能，可考慮函數指針（將失去所有靈活性）。