轉自：高性能架構探索

自從在使用?std::thread?構造函數過程中遇到了?Callable?類型的概念以來用到了很多關于它的使用.
因此本文把使用/調查結果總結出來. 包括 Callable 的基礎概念, 典型的?Callable?類型介紹.
例如函數對象(狹義), 函數指針, lambda 匿名函數, 函數適配器,?std::function?仿函數等.

Callable 類型

基礎

??定義(參考):可調用(Callable)?類型是可應用?INVOKE?操作(std::invoke?是在 C++17 里定義的類, 感覺意思就是執行函數操作的模板類.)

??要求:一個?T?類型要滿足為 callable 需要以下表達式在不求值語境中良構.INVOKE(f, [std::declval]ArgTypes>()...)?即?INVOKE(f, t1, t2, ..., tN).其中?f?為?T?類型的對象,?ArgTypes?為適合的實參類型列表,?R?為適合的返回類型.R為 void 的時可以表示為?static_cast(INVOKE(f, t1, t2, ..., tN)).

??詳細地

1.?若?f?是類?T?的成員函數指針: 上面等價于?(t1.*f)(t2, ..., tN)?或者?t1?是指針時?((*t1).*f)(t2, ..., tN).

2.?若?N == 1?且?f?是類?T?的數據成員指針:?INVOKE(f, t1)?等價于?t1.*f, 或者指針形式?(*t1).*f.

3.?均不滿足上面的情況表明?f?是一個函數對象(Function Object)?:?INVOKE(f, t1, t2, ..., tN)?等價于?f(t1, t2, ..., tN).

同時, 對于成員函數指針和數據成員指針,?t1?可以是一個常規指針或一個重載了?operator*?的類的對象, 例如智能指針?std::unique_ptr?或?std::shared_ptr.

可作為參數的標準庫

下列標準庫設施接受任何可調用(Callable)類型:

一些典型的 Callable 類型

函數對象 Function Object

一個重載了括號操作符()的對象, 也就是可以以f(args)形式進行函數調用的對象.

?

#include
#include
using?namespace?std;
class?Add?{
public:
????const?int?operator()(const?int?a,const?int?b){
????????return?a+b;}
};

int?main()?{
????Add?addFunction;?//函數對象
????cout<

	?

	我的第一印象是它跟函數指針有什么區別? 就像是個函數執行包裝器, 一個對象型的函數指針?

	但是函數對象本質上還是一個 class 的具體化 object, 里面是可以附帶一些成員變量(可以理解為函數對象的狀態(state))的, 這就讓函數對象的應用場景比函數指針更廣闊. 最典型的便是 STL 里了. C++ 的 STL 中的眾多 algorithm, 非常依賴于函數對象處理容器的元素. 想按照 STL 算法里的要求實現其功能要提供一些函數對象作為參數, 即謂詞參數(predicate). 例如對于?find_if?算法.

	?
class?NoLess{
public:
????NoLess(int?min?=?0):m_min(min){}
????bool?operator()?(int?value)?const{
????????return?value?>=?m_min;}
private:
????int?m_min;
};

find_if(dest.begin(),dest.end(),NoLess(10));??//dest容器里找是否存在不小于10的元素

	?

	對于普通函數來說, 只要簽名一致, 其類型就是相同的, 是類型不安全的. 但是這并不適用于函數對象, 因為函數對象的類型是其類的類型. 這樣, 函數對象有自己的類型, 這也意味著函數對象可以用于模板參數, 這對泛型編程有很大提升. 因為函數對象一般用于模板參數, 模板一般會在編譯時會做一些優化. 因此函數對象一般快于普通函數. 類也可以在使用的時候動態再產生, 節省成本.

	既然是類, 那就有它的限制, 例如要注意, 如同其他所有對象(狹義上的對象, 我感覺內置類型其實也可以被叫對象, 按場景區分吧)一樣, 如果 pass-by-value 的化, 對象里的成員變量是被復制進去的, 一旦對象被析構了, 里面的成員變量也是無法保存下來的. 所以可以 pass-by-reference/pointer.

	函數指針并不是沒有其用處了, 對于 C API 庫里的某些函數不支持函數對象還是有用武之地的. 例如??里面的排序函數?qsort?只能調用函數指針.

	?
void?qsort(?void?*ptr,?size_t?count,?size_t?size,int?(*comp)(const?void?*,?const?void?*)?);

	?

	函數

	除了普通的函數, 當然也包括類成員函數.

	這里不提及模板函數, 因為模板函數的概念只存在于編譯期, 運行期的函數沒有模板的概念, 都是經過完全特化過的, 因此與普通函數/類成員函數的概念是一致的.

	函數指針

	?
#include
#include
using?namespace?std;
int?AddFunc(int?a,?int?b)??{??
????return?a?+?b;}??

int?main()?{
????int?(*Add1)?(int?a,?int?b);?//函數指針,函數名兩側的()不可省略
????int?(*Add2)?(int?a,?int?b);
????Add1?=?&AddFunc;
????Add2?=?AddFunc;???????
????cout?<

	?

	Lambda 匿名函數(調用對象)

	好處是就地定義使用, 簡潔, 易維護.

	基本形式

	完整聲明:

	?
[capture?list]?(params?list)?mutable?exception->?return?type?{?function?body?}

	?

	各項具體含義如下

	1.?capture list: 捕獲外部變量列表.

	2.?params list: 形參列表.

	3.?mutable指示符: 用來說用是否可以修改捕獲的變量, 因為lambda的() operator() 默認是 const 的.

	4.?exception: 異常設定.

	5.?return type: 返回類型, 允許省略 lambda 表達式的返回值定義.

	6.?function body: 函數體.

	捕獲形式:

				捕獲形式
			

				說明
		

				[]
			

				不捕獲任何外部變量
		

				[變量名, …]
			

				默認以值得形式捕獲指定的多個外部變量(用逗號分隔), 如果引用捕獲, 需要顯示聲明(使用?&?說明符)
		

				[this]
			

				以值的形式捕獲?this?指針
		

				[=]
			

				以值的形式捕獲所有外部變量
		

				[&]
			

				以引用形式捕獲所有外部變量
		

				[=, &x]
			

				變量x以引用形式捕獲,其余變量以傳值形式捕獲
		

				[&, x]
			

				變量x以值的形式捕獲,其余變量以引用形式捕獲
		

	省略其中的某些成分來聲明”不完整”的Lambda表達式:

				序號
			

				格式
		

				1
			

				[capture list] (params list) -> return type {function body}
		

				2
			

				[capture list] (params list) {function body}
		

				3
			

				[capture list] {function body}
		

	一些關于 lambda 表達式的細節

	1.?延遲調用

	按值捕獲與按引用捕獲的區別.

	?
int?a?=?0;
auto?f?=?[=]{?return?a;?};??????//?按值捕獲外部變量
a?+=?1;?????????????????????????//?a被修改了
std::cout?<

	?

	2.?lambda 表達式轉換成函數指針沒有捕獲變量的 lambda 表達式可以直接轉換為函數指針, 而捕獲變量的 lambda 表達式則不能轉換為函數指針.

	?
typedef?void(*Ptr)(int*);
Ptr?p?=?[](int*?p){delete?p;};??//?正確,?沒有狀態的?lambda?(沒有捕獲)的lambda表達式可以直接轉換為函數指針
Ptr?p1?=?[&](int*?p){delete?p;};??//?錯誤,?有狀態的?lambda?不能直接轉換為函數指針

	?

	3.?嵌套

	?
int?m?=?[](int?x)?{?return?[](int?y)?{?return?y?*?2;?}(x)+6;?}(5);?//16

	?

	4.?作為 STL 算法函數謂詞參數:

	?
std::vector?myvec{?3,?2,?5,?7,?3,?2?};
std::sort(myvec.begin(),?myvec.end(),?[](int?a,?int?b)?->?bool?{?return?a?

	?

	C++14 中的 lambda 新特性

	1.?lambda 捕捉表達式/右值

	?
//?利用表達式捕獲,可以更靈活地處理作用域內的變量
int?x?=?4;
auto?y?=?[&r?=?x,?x?=?x?+?1]?{?r?+=?2;?return?x?*?x;?}();
//?此時?x?更新為6,y?為25

//?直接用字面值初始化變量
auto?z?=?[str?=?"string"]{?return?str;?}();
//?此時z是const?char*?類型,存儲字符串?string

//不能復制只能移動的對象,可以用std::move初始化變量
auto?myPi?=?std::make_unique(3.1415);
auto?circle_area?=?[pi?=?std::move(myPi)](double?r)?{?return?*pi?*?r?*?r;?};
cout?<

	?

	2.?泛型 lambda 表達式:

	?
auto?add?=?[](auto?x,?auto?y)?{?return?x?+?y;?};//推斷類型
int?x?=?add(2,?3);???//?5
double?y?=?add(2.5,?3.5);??//?6.0

	?

	函數適配器

	將函數對象與其它函數對象, 或者特定的值, 或者特定的函數相互組合的產物. 由于組合特性, 函數適配器可以滿足特定的需求, 頭文件??定義了幾種函數適配器:

	std::bind(op, args...): 將函數對象?op?的參數綁定到特定的值?args.

	std::mem_fn(op): 將類的成員函數轉化為一個函數對象.

	std::not1(op), std::not2(op),std::unary_negate,std::binary_negate: 一元取反器和二元取反器.

	std::bind

	這里的函數對象就包括了上面所有的類型, 當然也包含自己, 因此可以利用?std::bind?封裝出很多有意思的功能.

	下面的例子來自于分享.

	??嵌套

	?
//?定義一個接收一個參數,然后將參數加10再乘以2的函數對象
auto?plus10times2?=?std::bind(std::multiplies{},
????????std::bind(std::plus{},?std::_1,?10),?2);
cout?<{},
????????std::bind(std::multiplies{},?std::_1,?std::_1),
????????std::_1);
cout?<

	?

	??調用類中的成員函數

	?
class?Person{
public:
????Person(const?string&?n)?:?name{?n?}?{}
????void?print()?const?{?cout?<?p{?Person{"Tick"},?Person{"Trick"}?};
????//?調用成員函數print
????std::for_each(p.begin(),?p.end(),?std::bind(&Person::print,?std::_1));
????//?此處的std::_1表示要調用的Person對象,所以相當于調用arg1.print()
????//?輸出:?Tick???Trick
????std::for_each(p.begin(),?p.end(),?std::bind(&Person::print2,?std::_1,
????????"Person:?"));
????//?此處的std::_1表示要調用的Person對象,所以相當于調用arg1.print2("Person:?")
????//?輸出:?Person:?Tick???Person:?Trick

????return?0;
}

	?

	??調用 lambda 表達式

	?
vector?data{?1,?2,?3,?4?};
auto?func?=?std::bind([](const?vector&?data)?{?cout?<

	?

	??調用范圍內函數

	?
char?myToupper(char?c){
????if?(c?>=?'a'?&&?c?<=?'z')
????????return?static_cast(c?-?'a'?+?'A');
????return?c;
}

int?main()
{
????string?s{?"Internationalization"?};
????string?sub{?"Nation"?};
????auto?pos?=?std::search(s.begin(),?s.end(),?sub.begin(),?sub.end(),
????????????????????????std::bind(std::equal_to{},?
????????????????????????????std::bind(myToupper,?std::_1),
????????????????????????????std::bind(myToupper,?std::_2)));
????if?(pos?!=?s.end()){
????????cout?<

	?

	??默認 pass-by-value, 如果想要 pass-by-reference, 需要用?std::ref?和?std::cref?包裝.

	std::cref?比?std::ref?增加?const?屬性.

	?
void?f(int&?n1,?int&?n2,?const?int&?n3){
????cout?<

	?

	std::mem_fn

	與?std::bind?相比,?std::mem_fn?的范圍又要小一些, 僅調用成員函數, 并且可以省略掉用于調用對象的占位符.

	因此使用?std::men_fn?不需要綁定參數, 可以更方便地調用成員函數.

	?
vector?p{?Person{?"Tick"?},?Person{?"Trick"?}?};
std::for_each(p.begin(),?p.end(),?std::mem_fn(&Person::print));
//?輸出:?Trick?Trick
Person?n{?"Bob"?};
std::mem_fn(&Person::print2)(n,?"Person:?");
//?輸出:?Person:?Bob

	?

	std::mem_fn?還可以調用成員變量

	?
class?Foo{
public:
????int?data?=?7;
????void?display_greeting()?{?cout?<

	?

	std::not1 、std::not2、std::unary_negate、std::binary_negate

	std::not1,?std::not2?分別構造一個與謂詞結果相反的一元/二元函數對象.

	std::unary_negate,?std::binary_negate?分別返回其所保有的一元/二元謂詞的邏輯補的包裝函數對象, 其對象一般為?std::not1,?std::not2?構造的函數對象,即又加了一層包裝.

	下面分別是其使用示例:

	?
//std::not1
#include?
#include?
#include?
int?main(int?argc,?char?**argv)?
{??
????std::vector?nums?=?{5,?3,?4,?9,?1,?7,?6,?2,?8};
????std::function?less_than_5?=?[](int?x){?return?x?<=?5;?};
????//?count?numbers?of?integer?that?not?less?and?equal?than?5
????std::cout?<?nums?=?{5,?3,?4,?9,?1,?7,?6,?2,?8};
????std::function?ascendingOrder?=?[](int?a,?int?b)?{?return?a
#include?
#include?
#include?
struct?less_than_7?:?std::unary_function{
????bool?operator()(int?i)?const?{?return?i??v;
????for?(int?i?=?0;?i??not_less_than_7((less_than_7()));
????std::cout?<{
????bool?operator()(int?a,?int?b)?const?{?return?a?==?b;?}
};
?
int?main()
{
????std::vector?v1;
????std::vector?v2;
????for?(int?i?=?0;?i??v3(v1.size());
????std::binary_negate?not_same((same()));
????std::transform(v1.begin(),?v1.end(),?v2.begin(),?v3.begin(),?not_same);
?
????std::cout.setf(std::boolalpha);
????for?(int?i?=?0;?i?

	?

	std::not_fn

	注意 C++17 已經把上面的?std::not1,?std::not2,?std::unary_negate?和?std::binary_negate?拋棄, 統一由?std::not_fn?替代.

	?
//移除把滿足謂詞p的元素都copy到容器中
template?
auto?FilterRemoveCopyIf(const?std::vector&?vec,?Pred?p)?{
????std::vector?out;
????std::remove_copy_if(begin(vec),?end(vec),?
????????????????????????std::back_inserter(out),?std::not_fn(p));
????return?out;
}

	?

	std::function

	五花八門的?Callable, 個個都是人才, 但是不好帶(不好實現 generic programming), 所以一個把所有 callable 對象封裝成統一形式的類型模板.

	std::function?的實例可以對任何可以調用的目標實體進行存儲, 復制, 和調用操作, 實現一種類型安全的包裹.

	基礎介紹

	原型為:

	?
template?//R是返回值類型,Args是函數的參數類型
class?function;

	?

	其存儲的可調用對象被稱為?std::function?的目標. 若?std::function?不含目標, 則稱它為空. 調用空?std::function?的目標導致拋出?std::bad_function_call?異常.

	std::function?滿足可復制構造 (Copy Constructible) 和可復制賦值 (Copy Assignable) (參考).

	瑞士軍刀一般的功能, 代碼例子如下:

	?
#include?
#include?
?
struct?Foo?{
????Foo(int?num)?:?num_(num)?{}
????void?print_add(int?i)?const?{?std::cout?<?f_display?=?print_num;
????f_display(-9);
?
????//?存儲?lambda
????std::function?f_display_42?=?[]()?{?print_num(42);?};
????f_display_42();
?
????//?存儲到?std::bind?調用的結果
????std::function?f_display_31337?=?std::bind(print_num,?31337);
????f_display_31337();
?
????//?存儲到成員函數的調用
????std::function?f_add_display?=?&Foo::print_add;
????const?Foo?foo(314159);
????f_add_display(foo,?1);
????f_add_display(314159,?1);
?
????//?存儲到數據成員訪問器的調用
????std::function?f_num?=?&Foo::num_;
????std::cout?<?f_add_display2?=?std::bind(?&Foo::print_add,?foo,?_1?);
????f_add_display2(2);
?
????//?存儲到成員函數和對象指針的調用
????std::function?f_add_display3?=?std::bind(?&Foo::print_add,?&foo,?_1?);
????f_add_display3(3);
?
????//?存儲到函數對象的調用
????std::function?f_display_obj?=?PrintNum();
????f_display_obj(18);
?
????auto?factorial?=?[](int?n)?{
????????//?存儲?lambda?對象以模擬"遞歸?lambda?",注意額外開銷
????????std::function?fac?=?[&](int?n){?return?(n?

	?

	可能的輸出

	?
-9
42
31337
314160
314160
num_:?314159
314161
314162
18
5!?=?120;??6!?=?720;??7!?=?5040;

	?

	回調函數

	std::function?的應用之一: 結合?typedef?定義函數類型構造回調函數.

	?
typedef?std::function?CallBack;
Class?MessageProcessor?{
private:
????CallBack?callback_;
public:
????MessageProcessor(Callback?callback):callback_(callback){}
????void?ProcessMessage(const?std::string&?msg)?{
????????callback_(msg);
????}
};

	?

	　　審核編輯：湯梓紅

	?