腳本之家服務器常用軟件

快捷導航

C++11新增的包裝器詳解

更新時間：2022年08月26日 09:55:30 作者：小小酥誒

由于函數調用可以使用函數名、函數指針、函數對象或有名稱的lambda表達式，可調用類型太豐富導致模板的效率極低。包裝器用于解決效率低的問題

function

目前，我們的知識深度已知的可調用對象類型有：

函數指針
仿函數 / 函數對象
lambda表達式

現在我們有一個函數模板

   template<class F, class T>
   T useF(F f, T x)
   {
  		static int count = 0;
  	  	cout << "count:" << &count << endl;
     	return f(x);
   }

對于函數模板，編譯器會根據實參，按照模板定義出一份特定的函數。

函數內部的靜態(tài)成員變量是屬于函數的，無論調用多少次該函數，都只會定義出一個。

記住上面這兩個知識點，現在增加一個函數和仿函數，用來測試useF函數模板

int Sub(int num)
{
	return (num - 2);
}
struct Func
{
	int operator()(int num)
	{
		return (num - 3);
	}
};
int main()
{
	// 函數名
	cout << useF(Sub, 4) << endl;
	// 函數對象
	cout << useF(Func(), 4) << endl;
	// lambda表達式
	cout << useF([](int d)->int{ return (d - 4); }, 11.11) << endl;
	return 0;
}

解釋運行結果：我們在函數模板內部實現打印靜態(tài)成員變量，發(fā)現三次打印的cout地址不一樣。然而靜態(tài)成員變量是屬于函數的，一個函數的靜態(tài)成員變量無論調用多少次都只有一份。這說明是三個不同的函數調用。

以lambda表達式為例，一個lambda表達式語句就生成一個自定義類型（仿函數），那么多次調用會根據模板產生非常多的函數。

int main()
{
	// 函數名
	cout << useF(Sub, 4) << endl;
	// 函數對象
	cout << useF(Func(), 4) << endl;
	// lamber表達式
	cout << useF([](int d)->int{ return (d - 4); }, 11.11) << endl;
	cout << useF([](int d)->int { return (d - 4); }, 11.11) << endl;
	return 0;
}

其他可調用對象的類型也是很多的，許多的函數指針，許多的仿函數類，許多的lambda表達式……。類型太豐富了！對于一個模板而言，類型不同，就會對應定義出一份。模板的效率也降低了太多。

C++11提供了包裝器，包裝器可以將可調用對象統一包裝成一個類型。function就是一個包裝器，也可稱為適配器

function

#include <functional>
template <class Ret, class... Args> 
class function<Ret(Args...)>;

Ret(Args…)：第一個模板參數類型（參數包）

測試：

template<class F, class T>
T useF(F f, T x)
{
	static int count = 0;
	//cout << "count:" << ++count << endl;
	cout << "count:" << &count << endl;
	return f(x);
}
int main()
{
	function<int(int)> f1 = [](int d)->int { return (d - 4); };
	function<int(int)> f2 = [](int d)->int { return (d - 4); };
	function<int(int)> f3 = [](int d)->int { return (d - 4); };
	// lamber表達式
	cout << useF(f1, 5) << endl;
	cout << useF(f2, 5) << endl;
	cout << useF(f3, 5) << endl;
	return 0;
}

上面調用的都是同一個函數。

一個lambda表達式語句會生成一個類，上面有三個lambda表達式語句，生成三個類。使用function包裝器將這些可調用對象包裝成了一個類型，模板也就只需要定義出一份特定的，極大地提升了模板的效率。

【普通函數指針】

包裝用法：function<Ret(Args...)> 對象名 = 函數指針

//例如
int Sub(int x, int y)
{
	return x - y;
}
int main(void)
{
	//包裝函數指針
	function<int(int, int)> f1 = Sub;
	cout << f1(12, 8) << endl;
	return 0;
}

【仿函數】

包裝用法：function<Ret(Args……) 對象名 = 仿函數類()

class Sub
{
public:
	int operator()(int x, int y)
	{
		return (x - y);
	}
};
int main(void)
{
	function<int(int, int)> f2 = Sub();
	return 0;
}

【靜態(tài)類成員函數指針】

包裝方法：function<Ret(Args……) 對象名 = &類域::函數指針

& 可以不加，不影響結果，但是加上要更優(yōu)一些。

class Sub
{
public:
	static int SubStatic(int x, int y)
	{
		return (x - y);
	}
};
int main(void)
{
	function<int(int, int)> f2 = &Sub::SubStatic;
	cout << f2(10, 3) << endl;
	function<int(int, int)> f3 = Sub::SubStatic;
	cout << f2(10, 3) << endl;
	return 0;
}

【非靜態(tài)類成員函數指針】

包裝方法：function<Ret(類域名， Args……) 對象名 = &類域::函數指針

class Sub
{
public:
	int SubMember(int x, int y)
	{
		return (x - y);
	}
};
int main(void)
{
	function<int(Sub, int, int)> f4 = Sub::SubMember;
	cout << f4(Sub(), 3, 1) << endl;
	return 0;
}

非靜態(tài)類成員函數指針包裝后，使用包裝后的對象進行調用，第一個參數，必須是類名。

【lambda表達式】

包裝方法：function<Ret(Args……) 對象名 = lambda表達式

int main(void)
{
	function<double(double, double)> f5 = [](double x, double y)mutable->double {return x - y; };
	cout << f5(2.23, 1.11) << endl;
	return 0;
}

bind

bind也是一個包裝器。

作用一：調整參數的順序

普通函數指針的包裝方法：function<Ret(Args...)> 對象名 = bind(函數指針，newArgs……)

int Sub(int x, int y)
{
	return x - y;
}
int main(void)
{
	//function、bind包裝函數指針
	function<int(int, int)> f1 = Sub;
	//將第一個參數和第二個參數交換
	function<int(int, int)> f2 = bind(Sub, placeholders::_2, placeholders::_1);
	cout << f1(12, 8) << endl;
	cout << f2(12, 8) << endl;
	return 0;
}

placeholders::_n，表示當前function類中參數包的第n個參數。

希望怎么調整參數的順序，就在調用bind函數時，傳遞什么樣的參數順序。bind函數傳參時，使用placeholders::_n。

作用二、指定某個參數的值

#include <iostream>
#include <functional>
using namespace std;
int Sub(int x, int y)
{
	return x - y;
}
int main(void)
{
	//function、bind包裝函數指針
	function<int(int, int)> f2 = bind(Sub, 10, placeholders::_2);
	cout << f2(12, 8) << endl;
	return 0;
}

使用function和bind包裝過后，并且指定了某個參數的值。function實例化的時候可以省略掉指定了值的參數的參數類型。省略掉后要注意維護bind函數內的參數包。

int Sub(int x, int y)
{
	return x - y;
}
int main(void)
{
	//function、bind包裝函數指針
	function<int(int)> f2 = bind(Sub, 10, placeholders::_1);
	cout << f2(8) << endl;
	return 0;
}