目录
一、包装器
function包装器
function包装器介绍
function是一种函数包装器，也叫做适配器。它可以对可调用对象进行包装，C++中的function本质就是一个类模板。
function类模板的原型如下：
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret：被包装的可调用对象的返回值类型。Args...：被包装的可调用对象的形参类型。
如果我们想把三种可调用对象存到容器中去，那么我们应该如何解决类型问题？
函数指针、仿函数、lambda表达式，这三者是不同的类型，我们应该如何以一个统一的类型来适配这三种可调用对象的类型？
- 如果vector<>内写的是函数指针类型，那么vector的所有参数类型都只能接受该函数指针类型
- 如果vector<>内写的是仿函数类型，那么vector的所有参数类型都只能接受该仿函数类型；
- 而lambda都没法写，因为lambda类型只能由auto推导！无法显示的在vector<>内写出lambda类型
可以在vector<>内写auto吗？
不能。因为auto只能写在变量的左边，进行类型推导，auto连下面的写法都不支持，也就不可能写在vector<>内
auto ff; 错误写法那么这里就用到了包装器！可以体现包装器的价值。
包装示例
function包装器可以对可调用对象进行包装，包括函数指针（函数名）、仿函数（函数对象）、lambda表达式、类的成员函数。比如：
// 函数
double f(double x)
{
return x / 4;
}
// 仿函数
class Functor
{
public:
double operator()(double x)
{
return x / 4;
}
};
class Plus
{
public:
static double plus(double x)
{
return x / 4;
}
double func(double x)
{
return x / 4;
}
};
int main()
{
// 1. 包装函数指针（函数名）
function<double(double)> f1 = f;
// 2. 包装仿函数（函数对象）
function<double(double)> f2 = Functor();
// 3. 包装lambda表达式
function<double(double)> f3 = [](double x)->double { return x / 4; };
// 4. 包装类的静态成员变量
fuction<double(double)> f4 = &Plus::plus; // &可省略
// 用function<double(double)>类型统一管理这三种可调用对象类型
//vector<function<double(double)>> v{ f1, f2, f3, f4};
vector<function<double(double)>> v{ f, [](double x)->double {return x / 4; }, Functor(), Plus::plus};
double x = 3.14;
for (auto f : v)
{
cout << f(x++) << endl;
}
// 5. 包装类的静态成员变量
fuction<double(Plus, double)> f5 = &Plus::func; // &不可省略
cout << f5(Plus(), x) << endl;
return 0;
}注意事项：
- 包装时指明返回值类型和各形参类型，然后将可调用对象赋值给function包装器即可，包装后function对象就可以像普通函数一样使用了。
- 取静态成员函数的地址可以不用取地址运算符“&”，但取非静态成员函数的地址必须使用取地址运算符“&”。
- 包装非静态的成员函数时需要注意，非静态成员函数的第一个参数是隐藏this指针，因此在包装时需要指明第一个形参的类型为类的类型。
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()
{
//函数名
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包装器简化代码
其实上面的场景不太多，下面的使用场景最多
求解逆波兰表达式的步骤如下：
- 定义一个栈，依次遍历所给字符串。
- 如果遍历到的字符串是数字则直接入栈。
- 如果遍历到的字符串是加减乘除运算符，则从栈定抛出两个数字进行对应的运算，并将运算后得到的结果压入栈中。
- 所给字符串遍历完毕后，栈顶的数字就是逆波兰表达式的计算结果。
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 (const auto& str : tokens)
{
int left, right;
if (str == "+" || str == "-" || str == "*" || str == "/")
{
right = st.top();
st.pop();
left = st.top();
st.pop();
st.push(opMap[str](left, right));
}
else
{
st.push(stoi(str));
}
}
return st.top();
}
};
需要注意的是，这里建立的是运算符与function类型之间的映射关系，因此无论是函数指针、仿函数还是lambda表达式都可以在包装后与对应的运算符进行绑定。
function包装器的意义
- 将可调用对象的类型进行统一，便于我们对其进行统一化管理。
- 包装后明确了可调用对象的返回值和形参类型，更加方便使用者使用。
bind
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);也可以用function包装器接收，实际上bind底层也是重载了operator()的类，所以才能直接使用newCallable直接调用函数。
解释说明：
- 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包装器调整传参顺序
调整传参顺序
对于下面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;
}
注意：
- 如果bind类的静态成员函数，可调用对象前可以不加&，但是建议加上。
- 如果bind类的非静态成员函数，那么由于成员函数默认有一个this参数，所以需要传递类对象或类对象的地址！
- 既可以地址，也可以是对象，因为bind底层也是一个实现的operator()的类，我们传递的这个参数并不是给this的，而是仿函数内接收这个参数，如果是指针就是指针调用函数，如果是对象就用对象调用。看着玩的花的，基本都是仿函数
此时调用绑定后生成的可调用对象时，就只需要传入用于相减的两个参数了，因为在调用时会固定帮我们传入一个匿名对象给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包装器的意义
- 将一个函数的某些参数绑定为固定的值，让我们在调用时可以不用传递某些参数。
- 可以对函数参数的顺序进行灵活调整。
补充：
bind可以改变参数顺序，对于已经固定的常数（例如这里的rate），它不在参数的排列顺序中，即使rate在形参列表中间，也不影响palceholders的参数顺序
// rate在第三个参数
double Plus(int a, int b, double rate)
{
return (a + b) * rate;
}
// rate在第一个参数
double PPlus(double rate, int a, int b)
{
return rate * (a + b);
}
// rate在第一个参数
double PPPlus(int a, double rate, int b)
{
return rate * (a + b);
}
int main()
{
// rate在第三个参数，palceholders都是1、2
function<double(int, int)> Plus1 = bind(Plus, placeholders::_1, placeholders::_2, 1.41);
function<double(int, int)> Plus2 = bind(Plus, placeholders::_1, placeholders::_2, 1.73);
function<double(int, int)> Plus3 = bind(Plus, placeholders::_1, placeholders::_2, 2.23);
Plus1(1, 2);
Plus2(1, 2);
Plus3(1, 2);
// rate在第一个参数, palceholders都是1、2
function<double(int, int)> PPlus1 = bind(PPlus, 1.41, placeholders::_1, placeholders::_2);
function<double(int, int)> PPlus2 = bind(PPlus, 1.73, placeholders::_1, placeholders::_2);
function<double(int, int)> PPlus3 = bind(PPlus, 2.23, placeholders::_1, placeholders::_2);
PPlus1(1, 2);
PPlus2(1, 2);
PPlus3(1, 2);
// rate在中间, palceholders都是1、2
function<double(int, int)> PPPlus1 = bind(PPPlus, placeholders::_1, 1.41, placeholders::_2);
function<double(int, int)> PPPlus2 = bind(PPPlus, placeholders::_1, 1.73, placeholders::_2);
function<double(int, int)> PPPlus3 = bind(PPPlus, placeholders::_1, 2.23, placeholders::_2);
PPPlus1(1, 2);
PPPlus2(1, 2);
PPPlus3(1, 2);
return 0;
}function、 bind底层也是仿函数（类似lambda）
类的静态非静态成员函数bind
class SubType
{
public:
static int sub(int a, int b)
{
return a - b;
}
int ssub(int a, int b, int rate)
{
return (a - b) * rate;
}
};
int main()
{
// 绑定静态的成员函数，注意要写成地址 &SubType::sub
function<double(int, int)> Sub1 = bind(&SubType::sub, placeholders::_1, placeholders::_2);
// 因为普通成员函数有默认的this指针，所以需要多一个参数，这个参数可以使指针，也可以是对象
// 这是因为这个参数实际上并不是给this的，而是给bind底层的仿函数内部的，仿函数内部会使用指针访问ssub函数也可以使用对象访问ssub函数
// 绑定普通的成员函数
SubType st;
function<double(int, int)> Sub2 = bind(&SubType::ssub, &st, placeholders::_1, placeholders::_2, 3);
cout << Sub1(1, 2) << endl;
cout << Sub2(1, 2) << endl;
function<double(int, int)> Sub3 = bind(&SubType::ssub, SubType(), placeholders::_1, placeholders::_2, 3);
cout << Sub3(1, 2) << endl;
cout << typeid(Sub3).name() << endl;
return 0;
}- 因为普通成员函数有默认的this指针，所以需要多一个参数，这个参数可以是指针，也可以是对象，这是因为这个参数实际上并不是给this的，而是给bind底层的仿函数内部的，仿函数内部会使用指针访问ssub函数也可以使用对象访问ssub函数
- 绑定成员函数时，注意要写成地址 &SubType::sub
扫一扫
1002
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
