【C++】function包装器和bind包装器
-
-
- function包装器
-
- function包装器介绍
- 为什么要使用包装器
- function包装器简化代码
- bind包装器
-
- bind包装器介绍
- bind包装器绑定固定参数
- bind包装器调整传参顺序
-
function包装器
function包装器介绍
function是一种函数包装器，也叫做适配器。它可以对可调用对象进行包装，C++中的function本质就是一个类模板。
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
- Ret：被包装的可调用对象的返回值
- Args：被包装可调用对象的形参类型
包装示例
function包装器可以对可调用对象进行包装，包括函数指针（函数名）、仿函数（函数对象）、lambda表达式、类的成员函数。比如：
#include func4 = Plus::plusi;//&在静态成员函数时，可以选择不加
cout << func4(1, 2) << endl;
//5. 类的非静态成员函数
function<double(Plus,double, double)> func5 = &Plus::plusd;
cout << func5(Plus(), 1.1, 2.2) << endl;
return 0;
}
需要注意的是：
- 包装时指明返回值类型和各形参类型，然后将可调用对象赋值给function包装器即可，包装后function对象就可以像普通函数一样使用了。
- 取静态成员函数的地址可以不用取地址运算符“&”，但取非静态成员函数的地址必须使用取地址运算符“&”。
- 包装非静态的成员函数时需要注意，非静态成员函数的第一个参数是隐藏this指针，因此在包装时需要指明第一个形参的类型为类的类型。
为什么要使用包装器
- 简单来说，使用包装器可以统一我们的类型，
- 将可调用对象的类型进行统一，便于我们对其进行统一化管理。
- 包装后明确了可调用对象的返回值和形参类型，更加方便使用者使用。
具体看以下代码
我们分别创建多个不同类型的函数，然后让这些函数去调用我们的函数模板，然后进行回调。
对于以下函数模板useF：
- 传入该函数模板的第一个参数可以是任意的可调用对象，比如函数指针、仿函数、lambda表达式等。
- useF中定义了静态变量count，并在每次调用时将count的值和地址进行了打印，可判断多次调用时调用的是否是同一个useF函数
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);
}
在传入第二个参数类型相同的情况，如果我们传入的可调用对象不同，那么编译阶段该函数模板就会被实例化多此，比如：
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
};
int main()
{
//函数指针
cout << useF(f, 11.11) << endl;
//仿函数
cout << useF(Functor(), 11.11) << endl;
//lambda表达式
cout << useF([](double x)->double {return x / 4; },11.11);
return 0;
}
主要原因是：
- 由于函数指针、仿函数、lambda表达式是不同的类型，因此useF函数会被实例化出三份，三次调用useF函数所打印count的地址也是不同的。
为了解决这个问题，我们可以使用包装器对他的类型进行统一化，这样一来模板函数只会被实例化一次。
int main()
{
//函数名
function<double(double)> func1 = f;
cout << useF(func1, 11.11) << endl;
//函数对象
function<double(double)> func2 = Functor();
cout << useF(func2, 11.11) << endl;
//lambda表达式
function<double(double)> func3 = [](double d)->double {return d / 4; };
cout << useF(func3, 11.11) << endl;
return 0;
}
这时三次调用useF函数所打印count的地址就是相同的，并且count在三次调用后会被累加到3，表示这一个useF函数被调用了三次。
function包装器简化代码
链接: 逆波兰表达式求值
求解逆波兰表达式的步骤如下：
- 定义一个栈，依次遍历所给字符串。
- 如果遍历到的字符串是数字则直接入栈。
- 如果遍历到的字符串是加减乘除运算符，则从栈定抛出两个数字进行对应的运算，并将运算后得到的结果压入栈中。
- 所给字符串遍历完毕后，栈顶的数字就是逆波兰表达式的计算结果。
代码如下：
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> st;
for (const auto& str : tokens)
{
int left, right;
if (str == "+" || str == "-" || str == "*" || str == "/")
{
right = st.top();
st.pop();
left = st.top();
st.pop();
switch (str[0])
{
case '+':
st.push(left + right);
break;
case '-':
st.push(left - right);
break;
case '*':
st.push(left * right);
break;
case '/':
st.push(left / right);
break;
default:
break;
}
}
else
{
st.push(stoi(str));
}
}
return st.top();
}
};
在上述代码中，我们通过switch语句来判断本次需要进行哪种运算，如果运算类型增加了，比如增加了求余、幂、对数等运算，那么就需要在switch语句的后面中继续增加case语句。
这种情况可以用包装器来简化代码。
- 建立各个运算符与其对应需要执行的函数之间的映射关系，当需要执行某一运算时就可以直接通过运算符找到对应的函数进行执行。
- 当运算类型增加时，就只需要建立新增运算符与其对应函数之间的映射关系即可。
代码如下：
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> st;
unordered_map<string,function<int(int,int)>> opMap =
{
{ "+", [](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(auto& str : tokens)
{
if(str == "+" || str == "-" || str == "*" || str == "/")
{
int right = st.top();
st.pop();
int left = st.top();
st.pop();
st.push(opMap[str](left,right));
}
else
{
st.push(stoi(str));
}
}
return st.top();
}
};
bind包装器
bind包装器介绍
bind包装器可以规定为在进行包装类函数时，可以不用传this，可以定义为默认传
简单通俗的说，bing包装器就是用来调整参数的。而function是用来统一类型的。
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：要绑定的参数列表：值或占位符
调用bind的一般形式为：auto newCallable = bind(callable, arg_list);
解释说明：
- callable：需要包装的可调用对象。
- newCallable：生成新的可调用对象。
- arg_list：逗号分隔的参数列表，对应给定的callable的参数。当调用newCallable时，newCallable会调用callable，并传给它arg_list中的参数。
arg_list中的参数可能包含形如placeholders_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置，比如_1为newCallable的第一个参数，_2为第二个参数，以此类推。
此外，除了用auto接收包装后的可调用对象，也可以用function类型指明返回值和形参类型后接收包装后的可调用对象。
bind包装器绑定固定参数
#include 
此时调用绑定后新生成的可调用对象时就只需要传入一个参数，它会将该值与10相加后的结果进行返回。
bind包装器调整传参顺序
对于下面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);
cout << func(1, 2) << endl; //-1
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);
cout << func(1, 2) << endl; //1
return 0;
}
根本原因就是因为，后续调用新生成的可调用对象时，传入的第一个参数会传给placeholders::_1，传入的第二个参数会传给placeholders::_2，因此可以在绑定时通过控制placeholders::_n的位置，来控制第n个参数的传递位置。