包装器
一、function包装器
function包装器的引入
来看这样一行代码：
ret = func(x);
上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lamber表达式对象？所以这些都是可调用的类型！
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 d)->double { return d / 4; }, 11.11) << endl;
return 0;
}
通过上面的程序验证，我们会发现useF函数模板实例化了三份。每份count的地址都是不一样的。有没有办法让useF函数模板只实例化一份呢？为了让可调用的类型统一起来，C++11引入了function包装器来解决。
function包装器的概念
function包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。
function类模板的原型如下：
std::function在头文件<functional>
// 类模板原型如下
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret : 被调用函数的返回类型
Args…：被调用函数的形参
有了function包装器，就可以对可调用对象进行包装，包括函数指针（函数名）、仿函数、函数对象、lambda表达式、类的成员函数。示例：
#include <functional>
int f(int a, int b)
{
return a + b;
}
struct Functor
{
public:
int operator() (int a, int b)
{
return a + b;
}
};
class Plus
{
public:
static int plusi(int a, int b)
{
return a + b;
}
double plusd(double a, double b)
{
return a + b;
}
};
int main()
{
// 函数名(函数指针)
std::function<int(int, int)> func1 = f;
cout << func1(1, 2) << endl;//3
// 仿函数
std::function<int(int, int)> func2 = Functor();
cout << func2(10, 20) << endl;//30
// lambda表达式
std::function<int(int, int)> func3 = [](int a, int b) {return a + b; };
cout << func3(15, 25) << endl;//40
//类的静态成员函数
std::function<int(int, int)> func4 = Plus::plusi;//非静态成员函数必须加&，静态可不加
cout << func4(100, 200) << endl;//300
//类的非静态成员函数
std::function<double(Plus, double, double)> func5 = &Plus::plusd;//非静态成员函数必须加&，静态可不加
cout << func5(Plus(), 100.11, 200.11) << endl;//300.22
return 0;
}
注意：
- 类的成员函数在包装的时候记得指定类域
- 类的非静态成员函数必须加&，静态成员函数可加可不加
- 类的非静态成员函数存在隐含的this指针，包装的时候要多增加一个参数（类名），调用的时候多传一个类的匿名对象
使用function包装器优化逆波兰表达式求值
来看leetcode上这样一道题：逆波兰表达式求值
解决此题的步骤如下：
- 定义一个栈，遍历此数组
- 遍历到数字直接push入栈
- 若遍历到的字符串不是数字（“+”、“-”、“*”、"/"其中任意一个字符串），取栈顶的两个元素进行对应的算数运算，并把结果再push入栈。
- 遍历结束，最终栈顶的元素就是最终的值
代码如下：
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> st;
for (int i = 0; i < tokens.size(); i++)
{
if (!(tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/"))
{
st.push(stoi(tokens[i]));
}
else
{
int num1 = st.top();
st.pop();
int num2 = st.top();
st.pop();
if (tokens[i] == "+")
st.push(num1 + num2);
else if (tokens[i] == "-")
st.push(num2 - num1);
else if (tokens[i] == "*")
st.push((long)num1 * num2);
else if (tokens[i] == "/")
st.push(num2 / num1);
}
}
return st.top();
}
};
- 上述代码中，我主要是通过if、else语句来判断其进行何种运算，若后续运算类型增加了，那么还要增加if、else语句，多少有点冗余，我们可以使用包装器来优化此代码。
优化规则如下：
- 这里我们可以利用包装器建立操作符和对应函数的映射关系，这一步需要用到map容器，在列表初始化里头对每个操作符完成对应的函数映射关系
- 遍历数组，判断字符是否在map容器里头，如果在，说明是操作符，取栈顶的两个元素，进行相应的运算后，把结果push到栈里。
- 若字符不在map容器里头，说明是操作数，直接入栈
- 遍历结束，最后直接返回栈顶的元素
- 注意要防止栈溢出，要用long long的类型
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<long long> st;
map<string, function<long long(long long, long long)>> opFuncMap =
{
{"+", [](long long x, long long y){return x + y;}},
{"-", [](long long x, long long y){return x - y;}},
{"*", [](long long x, long long y){return x * y;}},
{"/", [](long long x, long long y){return x / y;}}
};
for (auto& str : tokens)
{
if (opFuncMap.count(str))//判断操作符是否在opFuncMap
{
long long right = st.top();
st.pop();
long long left = st.top();
st.pop();
st.push(opFuncMap[str](left, right));
}
else//操作数
{
st.push(stoi(str));
}
}
return st.top();
}
};
function包装器统一类型
对于以下函数模板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 d)->double{return d / 4; }, 11.11) << endl;
return 0;
}
由于函数指针、仿函数、lambda表达式是不同的类型，因此useF函数会被实例化出三份，三次调用useF函数所打印count的地址也是不同的。
- 但实际这里根本没有必要实例化出三份useF函数，因为三次调用useF函数时传入的可调用对象虽然是不同类型的，但这三个可调用对象的返回值和形参类型都是相同的。
- 这时就可以用包装器分别对着三个可调用对象进行包装，然后再用这三个包装后的可调用对象来调用useF函数，这时就只会实例化出一份useF函数。
- 根本原因就是因为包装后，这三个可调用对象都是相同的function类型，因此最终只会实例化出一份useF函数，该函数的第一个模板参数的类型就是function类型的。
代码如下：
int main()int main()
{
//函数名
function<double(double)> func1 = func;
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包装器的意义
- 将可调用对象的类型进行统一，便于我们对其进行统一化管理。
- 包装后明确了可调用对象的返回值和形参类型，更加方便使用者使用。
二、bind包装器
bind包装器介绍
bind也是一种函数包装器，也叫做适配器。它可以接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表，C++中的bind本质是一个函数模板。
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的一般形式
调用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类型指明返回值和形参类型后接收包装后的可调用对象。
bind包装器绑定固定参数
无意义的绑定
下面这种绑定就是无意义的绑定：
int Plus(int a, int b)
{
return a + b;
}
int main()
{
//无意义的绑定
function<int(int, int)> func = bind(Plus, placeholders::_1, placeholders::_2);
cout << func(1, 2) << endl; //3
return 0;
}
绑定时第一个参数传入函数指针这个可调用对象，但后续传入的要绑定的参数列表依次是placeholders::_1和placeholders::_2，表示后续调用新生成的可调用对象时，传入的第一个参数传给placeholders::_1，传入的第二个参数传给placeholders::_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);
cout << func(2) << endl; //12
return 0;
}
此时调用绑定后新生成的可调用对象时就只需要传入一个参数，它会将该值与10相加后的结果进行返回。
bind包装器调整传参顺序
调整传参顺序
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个参数的传递位置。
bind包装器的意义
- 将一个函数的某些参数绑定为固定的值，让我们在调用时可以不用传递某些参数。
- 可以对函数参数的顺序进行灵活调整。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
