C++可調(diào)用對象callable object深入分析

更新時間：2022年08月25日 09:09:34 作者：殺神李

所謂的callable object，表示可以被某種方式調(diào)用其某些函數(shù)的對象。它可以是：一個函數(shù)、一個指向成員函數(shù)的指針、一個函數(shù)對象，該對象擁有operator()、一個lambda表達式，嚴格的說它是一種函數(shù)對象

本作者一致的觀點就是在任何語言執(zhí)行的時候先去思考匯編層面能不能做到如果能做到那么高級語言才能做到無論你推出什么新特性用戶態(tài)匯編你都是繞不開的比如你要調(diào)用函數(shù) 那么你必須要使用call指令那么就必須要有函數(shù)地址接下來我們來詳細說說為什么c++11要推出這個新概念以及他解決了什么問題還有如何使用它

Tips:c++的設(shè)計哲學(xué)是你必須時刻清楚你自己在干什么 stl內(nèi)部并不會給你執(zhí)行任何的安全檢查程序直接崩潰也是完全有可能的功力不夠就不要玩花的

為什么需要他

在c++11還沒有推出callable object的時候那時候如果你想要把普通函數(shù)當(dāng)做參數(shù)一樣傳遞那么你就只能使用函數(shù)指針如下段代碼所示

我就不再演示如果你有函數(shù)指針如何調(diào)用函數(shù)了空指針發(fā)生調(diào)用異常啥的也是你自己的問題那非常簡單了不需要過多描述

注意 FuncP是一種類型而非一個指針

#include <iostream>
void test(int i)
{
	return;
}
typedef void(*FuncP)(int i);
void recevier(void(*)(int))
{
	std::cout << "recevier working!" << std::endl;
}
int main()
{
	recevier(&test);
	FuncP ding = test;
	recevier(&test);
	void(*FuncP1)(int) = test;
	recevier(FuncP1);
}

運行結(jié)果截圖:

而如果你想把類的成員函數(shù)傳遞那更是麻煩因為我們知道類的成員函數(shù)在調(diào)用的時候是需要傳遞this指針的那么我們來看一看如何傳遞類的成員函數(shù) 如下段代碼所示

#include <iostream>
class testclass
{
public:
	void MemberFunc(int i)
	{
		std::cout << "MemberFunc" << std::endl;
	}
};
typedef void(testclass::* CFuncP)(int);
void recevier(void(testclass::* memberFunc)(int))
{
	testclass p;
	(p.*memberFunc)(1);
	std::cout << "recevier working!" << std::endl;
}
void recevier(void(*)(int))
{
	std::cout << "recevier working!" << std::endl;
}
int main()
{
	recevier(&testclass::MemberFunc);
	CFuncP ding = &testclass::MemberFunc;
	recevier(ding);
	void(testclass:: * testF)(int) = &testclass::MemberFunc;
	recevier(testF);
}

運行結(jié)果如下圖

可以看到啊雖然咱們用普通的成員函數(shù)指針和普通的函數(shù)指針?biāo)坪跻呀?jīng)可以解決絕大部分問題那為什么又要推出一個callable object呢? 關(guān)鍵在于這種代碼實現(xiàn)起來其實可讀性很差而且不是那么好理解如果有一種統(tǒng)一的方式來讓我們可以把函數(shù)當(dāng)做參數(shù)傳遞并且能直接調(diào)用就好了那么c++11便推出了callable object

他究竟是啥

那么究竟什么叫做callable object呢顧名思義就是可以被調(diào)用的對象看如下一個最簡單的例子

#include <iostream>
class testclass
{
public:
	void MemberFunc(int i)
	{
		std::cout << "MemberFunc" << std::endl;
	}
	void operator()()
	{
		std::cout << "callable object working" << std::endl;
	}
};
int main()
{
	testclass ding;
	ding();
}

當(dāng)一個對象重載了() 運算符的時候我們就把他看做一個最簡單的callable object 因為他這個對象可以像函數(shù)一樣被調(diào)用是吧沒有什么問題那么接下來我們就來看看stl提供的能讓你快速生成callable object的組件之std::bind

他怎樣被使用呢

我們先來看一個最簡單的例子基于std::bind

void test(int i, int j, int k)
{
	std::cout << "test working!" << std::endl;
	std::cout << i << std::endl;
	std::cout << j << std::endl;
	std::cout << k << std::endl;
}
int main()
{
	std::bind(&test, 1, 2, 3)();
}

如上圖所示我們使用std::bind來創(chuàng)建了一個callable object并且在創(chuàng)建這個callable object的時候就已經(jīng)把他三個參數(shù)傳遞好了這點非常重要這會影響到接下來的占位符的講解然后馬上使用()來調(diào)用了他運行結(jié)果如下圖所示

相比較于普通的函數(shù)指針這樣的方式是不是更簡單明了了呢？當(dāng)然這遠遠不是他的全部接下來我們來看看使用占位符的時候該如何使用它代碼如下圖所示

void test(int i, int j, int k)
{
	std::cout << "test working!" << std::endl;
	std::cout << i << std::endl;
	std::cout << j << std::endl;
	std::cout << k << std::endl;
}
int main()
{
	std::bind(&test, 1,std::placeholders::_1,std::placeholders::_2)(2,3);
}

可以看到上圖我們在創(chuàng)建callable object的時候并沒有去傳遞全部的參數(shù) 而是使用了占位符然后在真正調(diào)用的時候才去傳遞了2和3兩個參數(shù) 運行結(jié)果如下圖所示

下面讓我們升華到成員函數(shù)好嘛？不過多講解咱們直接看代碼

#include <iostream>
#include <functional>
class testclass
{
public:
	void MemberFunc(int i,int j,int k)
	{
		std::cout << "MemberFunc" << std::endl;
		std::cout << i << std::endl;
		std::cout << j << std::endl;
		std::cout << k << std::endl;
	}
	void operator()()
	{
		std::cout << "callable object working" << std::endl;
	}
};
int main()
{
	std::bind(&testclass::MemberFunc, testclass(), 1, std::placeholders::_1, std::placeholders::_2)(2, 3);
}

成員函數(shù)的調(diào)用時需要this指針的我相信大家都知道那么這就是為什么我在std::bind的第二個參數(shù)創(chuàng)建了一個臨時對象用來傳遞this指針可以看到相比較于普通的成員函數(shù)指針這種方式明顯要方便的多注意啊使用std::bind來創(chuàng)建成員函數(shù)的callable object的時候第二個參數(shù)必須是對象或者某個對象的this指針不然直接會G的

亂玩導(dǎo)致的G 你自己負責(zé) 如下圖所示

當(dāng)然像下圖這樣先使用占位符將傳入對象暫定然后在參數(shù)中去傳遞對象或this指針也是可以的

std::bind
(&testclass::MemberFunc,std::placeholders::_1, 1, std::placeholders::_2,
std::placeholders::_3)(testclass(),2, 3);

這個時候你就要問了 OK 這樣確實很方便沒錯但是你說了這么久也沒見你把它當(dāng)做參數(shù)來傳遞啊下面就來介紹std::function 他不僅能當(dāng)做參數(shù)來傳遞并且還可以保存callable object 屬實是非常方便老樣子還是從最簡單的例子開始代碼如下圖

#include <iostream>
#include <functional>
class testclass
{
public:
	int ding{};
	void MemberFunc(int i,int j,int k)
	{
		std::cout << "MemberFunc" << std::endl;
		std::cout << i << std::endl;
		std::cout << j << std::endl;
		std::cout << k << std::endl;
		std::cout << ding << std::endl;
	}
	void operator()()
	{
		std::cout << "callable object working" << std::endl;
	}
};
int main()
{
	std::function<void(int,int,int)>MemberCall=std::bind(&testclass::MemberFunc,testclass(), 1, std::placeholders::_1, std::placeholders::_2);
	MemberCall(1,2,NULL);
	std::function<void(testclass&, int, int, int) > MemberCall2=&testclass::MemberFunc;
	testclass C;
	MemberCall2(C, 1, 1, 1);
}

如上圖所示因為我已經(jīng)放置了一個占位符所以呢第三個參數(shù)無論你填什么都是沒用的只會取前兩個參數(shù) 調(diào)用結(jié)果如下所示:

我們再來試試將他作為參數(shù)傳遞很簡單咯玩起來

void test(std::function<void(int, int, int)>& Func, int c)
{
	Func(1, 2, 3);
	std::cout << c<<std::endl;
}
int main()
{
	std::function<void(int,int,int)>MemberCall=std::bind(&testclass::MemberFunc,testclass(), 1, std::placeholders::_1, std::placeholders::_2);
	MemberCall(1,2,NULL);
	std::function<void(testclass&, int, int, int) > MemberCall2=&testclass::MemberFunc;
	testclass C;
	MemberCall2(C, 1, 1, 1);
	test(MemberCall, 3);
}

運行結(jié)果如下:

看看有了std::function和std::bind 函數(shù)就像對象一樣可以被傳遞保存和調(diào)用是不是很方便呢

Tips:既然他是一個對象了那任何對對象的操作對于他都是允許的比如塞入隊列啥的可以任意交互其他東西我就不演示了對于對象的各種操作是基本知識

最后讓我們來看看他跟lambda之間的化學(xué)反應(yīng) 代碼如下:

#include <iostream>
#include <functional>
class testclass
{
public:
	int ding{};
	void MemberFunc(int i,int j,int k)
	{
		std::cout << "MemberFunc" << std::endl;
		std::cout << i << std::endl;
		std::cout << j << std::endl;
		std::cout << k << std::endl;
		std::cout << ding << std::endl;
	}
	void operator()()
	{
		std::cout << "callable object working" << std::endl;
	}
};
void test(std::function<void(int, int, int)>& Func, int c)
{
	Func(1, 2, 3);
	std::cout << c<<std::endl;
}
int main()
{
	std::function<void(int,int,int)>MemberCall=std::bind(&testclass::MemberFunc,testclass(), 1, std::placeholders::_1, std::placeholders::_2);
	std::function<void(testclass&&,int, int, int)>MemberCall1 = std::bind(&testclass::MemberFunc, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,std::placeholders::_4);
	MemberCall1(testclass(),1, 2, 3);
	MemberCall(1,2,3);
	std::function<void(testclass&, int, int, int) > MemberCall2=&testclass::MemberFunc;
	testclass C;
	MemberCall2(C, 1, 1, 1);
	test(MemberCall, 3);
	std::function<bool(int,int,int)> play=std::bind([&C](testclass& c, int i, int j, int k)->bool {
		c.MemberFunc(i, j, k);
		std::cout << "lambda working!" << std::endl;
		}, C, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
	play(1, 2, 3);
}

運行結(jié)果如下