【C++11】包装器

最新推荐文章于 2024-03-11 16:58:34 发布

2022horse

最新推荐文章于 2024-03-11 16:58:34 发布

阅读量977

点赞数 19

分类专栏： C++进阶文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/m0_70088010/article/details/135996170

版权

C++进阶专栏收录该内容

26 篇文章 0 订阅

订阅专栏

包装器

一、function包装器
二、bind包装器

一、function包装器

1、function包装器介绍

function是一种函数包装器，也叫做适配器。它可以对可调用对象进行包装，C++中的function本质就是一个类模板。

function类模板的原型如下：

template <class T> function;     // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;

模板参数说明：

Ret：被包装的可调用对象的返回值类型。
Args...：被包装的可调用对象的形参类型。

2、包装示例

unction包装器可以对可调用对象进行包装，包括函数指针（函数名）、仿函数（函数对象）、lambda表达式、类的成员函数。

#define _CRT_CURTUE_WARNINGS 1
#include<iostream>
#include<functional>
using namespace std;

// 函数
int f(int a, int b)
{
	return a + b;
}
// 仿函数
struct Function
{
	int operator()(int a, int b)
	{
		return a + b;
	}
};
// plus类
class Plus
{
public:
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return a + b;
	}
};

int main()
{
	// 1、包装函数指针（函数名）
	function<int(int, int)> func1 = f;
	std::cout << func1(1, 2) << std::endl;

	// 2、包装仿函数（函数对象）
	function<int(int, int)> func2 = Function();
	std::cout << func2(2, 4) << std::endl;

	// 3、包装lambda表达式
	function<int(int, int)> func3 = [](int a, int b) {return a + b; };
	std::cout << func3(6, 8) << std::endl;

	// 4、包装类内静态成员函数
	function<int(int, int)> func4 = &Plus::plusi; // &可以省略
	std::cout << func4(7, 9) << std::endl;

	// 5、包装类内非静态成员函数
	function<double(Plus, double, double)> func5 = &Plus::plusd; // &不可省略
	std::cout << func5(Plus(), 1.1, 2.2) << std::endl;

	return 0;
}

在这里插入图片描述

注意：

包装时指明返回值类型和各形参类型，然后将可调用对象赋值给function包装器即可，包装后function对象就可以像普通函数一样使用了。
取静态成员函数的地址可以不用取地址运算符“&”，但取非静态成员函数的地址必须使用取地址运算符“&”。
包装非静态的成员函数时需要注意，非静态成员函数的第一个参数是隐藏this指针，因此在包装时需要指明第一个形参的类型为类的类型。

3、function包装器统一类型

对于以下函数模板useF：

传入该函数模板的第一个参数可以是任意的可调用对象，比如函数指针、仿函数、lambda表达式等。
useF中定义了静态变量count，并在每次调用时将count的值和地址进行了打印，可判断多次调用时调用的是否是同一个useF函数。

useF代码如下：

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

在传入第二个参数类型相同的情况下，如果传入的可调用对象的类型是不同的，那么在编译阶段该函数模板就会被实例化多次。

// 函数
double f(double a)
{
	return a / 2;
}
// 仿函数
struct Function
{
public:
	double operator()(double a)
	{
		return a / 4;
	}
};

int main()
{
	// 1、函数指针
	std::cout << useF(f, 11.11) << std::endl;

	// 2、仿函数
	std::cout << useF(Function(), 11.11) << std::endl;

	// 3、lambda表达式
	std::cout << useF([](double d)->double {return d / 4; }, 11.11) << std::endl;
	return 0;
}

在这里插入图片描述
由于函数指针、仿函数、lambda表达式是不同的类型，因此useF函数会被实例化出三份，三次调用useF函数所打印count的地址也是不同的。

但实际这里根本没有必要实例化出三份useF函数，因为三次调用useF函数时传入的可调用对象虽然是不同类型的，但这三个可调用对象的返回值和形参类型都是相同的。
这时就可以用包装器分别对着三个可调用对象进行包装，然后再用这三个包装后的可调用对象来调用useF函数，这时就只会实例化出一份useF函数。
根本原因就是因为包装后，这三个可调用对象都是相同的function类型，因此最终只会实例化出一份useF函数，该函数的第一个模板参数的类型就是function类型的。

如下代码：

int main()
{
	// 1、函数指针
	function<double(double)> func1 = f;
	std::cout << useF(func1, 11.11) << std::endl;

	// 2、仿函数
	function<double(double)> func2 = Function();
	std::cout << useF(func2, 11.11) << std::endl;

	// 3、lambda表达式
	function<double(double)> func3 = [](double x)->double {return x / 4; };
	std::cout << useF(func3, 11.11) << std::endl;
	return 0;
}

这时三次调用useF函数所打印count的地址就是相同的，并且count在三次调用后会被累加到3，表示这一个useF函数被调用了三次。
在这里插入图片描述

4、function包装器简化代码

我们用我们的老朋友–逆波兰表达式来进行讲解：

class Solution
{
public:
	int evalRPN(vector<string>& tokens)
	{
		// 定义一个栈
		stack<int> t;
		// 从数组中选择
		for (const auto& str : tokens)
		{
			int left;
			int right;
			// 如果是+-*/操作符则进入switch
			if (str == "+" || str == "-" && str == "*" && str == "/")
			{
				// 取出栈顶两个元素
				left = t.top();
				t.pop();
				right = t.top();
				t.pop();
				// switch
				switch (str[0])
				{
				case '+':
					t.push(left + right);
					break;
				case '-':
					t.push(left - right);
					break;
				case '*':
					t.push(left * right);
					break;
				case '/':
					if (right == 0)
					{
						return;
					}
					else
					{
						t.push(left / right);
						break;
					}
				default:
					break;
				}
			}
			else
			{
				t.push(stoi(str));
			}
		}
		return t.top();
	}
};

上述代码中，我们通过switch语句来判断本次需要进行哪种运算，如果运算类型增加了，比如增加了求余、幂、对数等运算，那么就需要在switch语句的后面中继续增加case语句。

建立各个运算符与其对应需要执行的函数之间的映射关系，当需要执行某一运算时就可以直接通过运算符找到对应的函数进行执行。
当运算类型增加时，就只需要建立新增运算符与其对应函数之间的映射关系即可。

class Solution
{
public:
	int evalRPN(vector<string>& tokens)
	{
		// 定义一个栈
		stack<int> t;
		unordered_map<string, function<int(int, int)>> op =
		{
			{"+", [](int a, int b) {return a + b; }},
			{"-", [](int a, int b) {return a - b; }},
			{"*", [](int a, int b) {return a * b; }},
			{"/", [](int a, int b) {return a / b; }}
		};
		for (const auto& str : tokens)
		{
			int left;
			int right;
			if (str == "+" || str == "-" || str == "*" || str == "/")
			{
				left = t.top();
				t.pop();
				right = t.top();
				t.pop();
				t.push(op[str](left, right));
			}
			else
			{
				t.push(stoi(str));
			}
		}
		return t.top();
	}
};

这里建立的是运算符与function类型之间的映射关系，因此无论是函数指针、仿函数还是lambda表达式都可以在包装后与对应的运算符进行绑定。

5、function包装器的意义

将可调用对象的类型进行统一，便于我们对其进行统一化管理。
包装后明确了可调用对象的返回值和形参类型，更加方便使用者使用。

二、bind包装器

1、bind包装器介绍

（1）bind包装器

bind也是一种函数包装器，也叫做适配器。它可以接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表，C++中的bind本质是一个函数模板。

template <class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);
template <class Ret, class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);

模板参数说明：

fn：可调用对象。
args...：要绑定的参数列表：值或占位符。

（2）调用bind的一般形式

调用bind的一般形式为：auto newCallable = bind(callable, arg_list);

解释说明：

callable：需要包装的可调用对象。
newCallable：生成的新的可调用对象。
arg_list：逗号分隔的参数列表，对应给定的callable的参数。当调用newCallable时，newCallable会调用callable，并传给它arg_list中的参数。

arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是**“占位符”**，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置，比如_1为newCallable的第一个参数，_2为第二个参数，以此类推。
此外，除了用auto接收包装后的可调用对象，也可以用function类型指明返回值和形参类型后接收包装后的可调用对象。

2、bind包装器绑定固定参数

（1）无意义的绑定

int Plus(int a, int b)
{
	return a + b;
}

int main()
{
	// 无意义的绑定
	function<int(int, int)> func = bind(Plus, placeholders::_1, placeholders::_2);
	std::cout << func(1, 2) << std::endl;
	return 0;
}

在这里插入图片描述

绑定时第一个参数传入函数指针这个可调用对象，但后续传入的要绑定的参数列表依次是placeholders::_1和placeholders::_2，表示后续调用新生成的可调用对象时，传入的第一个参数传给placeholders::_1，传入的第二个参数传给placeholders::_2。此时绑定后生成的新的可调用对象的传参方式，和原来没有绑定的可调用对象是一样的，所以说这是一个无意义的绑定。

（2）绑定固定参数

如果想把Plus函数的第二个参数固定绑定为10，可以在绑定时将参数列表的placeholders::_2设置为10。

int Plus(int a, int b)
{
	return a + b;
}

int main()
{
	function<int(int)> func = bind(Plus, placeholders::_1, 10);
	std::cout << func(2) << std::endl;
	return 0;
}

在这里插入图片描述
此时调用绑定后新生成的可调用对象时就只需要传入一个参数，它会将该值与10相加后的结果进行返回。

3、bind包装器调整传参顺序

（1）调整传参顺序

对于下面Sub类中的sub成员函数，sub成员函数的第一个参数是隐藏的this指针，如果想要在调用sub成员函数时不用对象进行调用，那么可以将sub成员函数的第一个参数固定绑定为一个Sub对象。

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};

int main()
{
	function<int(int, int)> func = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
	std::cout << func(1, 2) << std::endl;
	return 0;
}

在这里插入图片描述
此时调用绑定后生成的可调用对象时，就只需要传入用于相减的两个参数了，因为在调用时会固定帮我们传入一个匿名对象给this指针。
如果想要将sub成员函数用于相减的两个参数的顺序交换，那么直接在绑定时将placeholders::_1和placeholders::_2的位置交换一下就行了。

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};

int main()
{
	function<int(int, int)> func = bind(&Sub::sub, Sub(), placeholders::_2, placeholders::_1);
	std::cout << func(1, 2) << std::endl;
	return 0;
}

在这里插入图片描述
根本原因就是因为，后续调用新生成的可调用对象时，传入的第一个参数会传给placeholders::_1，传入的第二个参数会传给placeholders::_2，因此可以在绑定时通过控制placeholders::_n的位置，来控制第n个参数的传递位置。

（2）bind包装器的意义

将一个函数的某些参数绑定为固定的值，让我们在调用时可以不用传递某些参数。
可以对函数参数的顺序进行灵活调整。

2022horse

关注

19
点赞
踩
10

收藏

觉得还不错? 一键收藏
打赏
0
评论
【C++11】包装器

function是一种函数包装器，也叫做适配器。它可以对可调用对象进行包装，C++中的function本质就是一个类模板。function类模板的原型模板参数说明Ret：被包装的可调用对象的返回值类型。Args...：被包装的可调用对象的形参类型。bind也是一种函数包装器，也叫做适配器。它可以接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表，C++中的bind本质是一个函数模板。模板参数说明fn：可调用对象。args...：要绑定的参数列表：值或占位符。
复制链接

扫一扫