目录
- 传统艺能😎
- 概念🤔
- 类型统一🤔
- 意义🤔
- bind 包装器😎
- bind 绑定固定参数😎
- 调整传参顺序😎
传统艺能😎
概念🤔
所谓的包装器其实就是 function 包装器,也称为适配器,他的功能就是对可调用对象进行包装,包装器底层原理的本质其实就是类模板
包装器定义式:
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
其中的 是被包装的可调用对象的返回值类型,
function包装器可以对可调用对象进行包装,包括函数指针、函数名、仿函数(函数对象)、lambda表达式、类的成员函数:
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()
{
//包装函数指针、函数名
function<int(int, int)> func1 = f;
cout << func1(1, 2) << endl;
//包装仿函数(函数对象)
function<int(int, int)> func2 = Functor();
cout << func2(1, 2) << endl;
//包装lambda表达式
function<int(int, int)> func3 = [](int a, int b){return a + b; };
cout << func3(1, 2) << endl;
//类的静态成员函数
//function<int(int, int)> func4 = Plus::plusi;
function<int(int, int)> func4 = &Plus::plusi; //&可省略
cout << func4(1, 2) << endl;
//类的非静态成员函数
function<double(Plus, double, double)> func5 = &Plus::plusd; //&不可省略
cout << func5(Plus(), 1.1, 2.2) << endl;
return 0;
}
如我上面所注:
取静态成员函数的地址可以不用 &,但取非静态成员函数的地址必须使用 &;包装非静态的成员函数时还需要注意,非静态成员函数第一个参数是隐藏 this 指针,因此在包装时需要指明第一个形参的类型为类的类型
包装时指明返回值类型和各形参类型,然后将可调用对象赋值给function包装器即可,包装后function对象就可以像普通函数一样使用了,
类型统一🤔
template<class F, class T>
T func(F f, T x)
{
static int a = 0;
cout << "a: " << ++a << endl;
cout << "a: " << &a << endl;
return f(x);
}
对于一个函数模板,传入该函数模板的第一个参数可以是任意的可调用对象,比如函数指针、仿函数、lambda 表达式等;类模板中定义了静态变量 a,并在每次调用时将对象 a 的值和地址进行了打印,可判断多次调用时调用的是否是同一个函数
在传入第二个参数类型相同的情况下,如果传入的可调用对象的类型是不同的,那么在编译阶段该函数模板就会被实例化多次:
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
};
int main()
{
//函数指针
cout << func(f, 11.11) << endl;
//仿函数
cout << func(Functor(), 11.11) << endl;
//lambda表达式
cout << func([](double d)->double{return d / 4; }, 11.11) << endl;
return 0;
由于函数指针、仿函数、lambda 表达式是不同的类型,因此 func 函数会被实例化出三份,三次调用 func 函数所打印 a 的地址也是不同的
但实际上根本没必要实例化出三份 func 函数,因为这三个可调用对象的返回值和形参类型都是相同的,这时就可以用包装器分别对三个可调用对象进行包装,然后再用这三个包装后的可调用对象来调用 func 函数,这时就只会实例化出一份 func 函数
根本原因就是因为包装后,这三个可调用对象都是相同的 function 类型,因此最终只会实例化出一份 func 函数,该函数的第一个模板参数的类型就是 function 类型的
int main()
{
//函数名
function<double(double)> func1 = func;
cout << func(func1, 11.11) << endl;
//函数对象
function<double(double)> func2 = Functor();
cout << func(func2, 11.11) << endl;
//lambda表达式
function<double(double)> func3 = [](double d)->double{return d / 4; };
cout << func(func3, 11.11) << endl;
return 0;
}
这时三次调用 func 函数打印 a 的地址就是相同的,并且 a 在三次调用后会被累加到 3,表示这一个 func 函数被调用了三次:
求解逆的步骤如下:
定义一个栈,依次遍历所给字符串,如果遍历到的字符串是数字则直接入栈。
如果遍历到的字符串是 ±*/,则从栈顶抛出两个数字进行对应的运算,并将运算后得到的结果压入栈中。
所给字符串遍历完毕后,栈顶的数字就是逆波兰表达式计算结果
按照以前的思路,本题应该对不同的情况进行分类讨论,典型的 switch-case 模型,如下:
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-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表达式都可以在包装后与对应的运算符进行绑定
意义🤔
- 将可调用对象的类型进行统一,便于对其进行统一化管理
- 包装后明确了可调用对象的返回值和形参类型,更加方便使用
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 调用形式:
auto newCallable = bind(callable, arg_list);
callable:需要包装的可调用对象
newCallable:生成的新的可调用对象
arg_list:逗号分隔的参数列表,对应给定的 callable 的参数,当调用 newCallable时,newCallable 会调用 callable,并传给它 arg_list 中的参数
arg_list 中的参数可能包含形如 _n 的名字,其中 n 是一个整数,这些参数是占位符,它们占据了传递给 newCallable 的参数的“位置”。数值 n 表示生成的可调用对象中参数的位置,比如 _1 为 newCallable 第一个参数,_2 为第二个参数,以此类推。
此外,除了用 auto 接收包装后的可调用对象,也可以用 function 类型指明返回值和形参类型后接收包装后的可调用对象
bind 绑定固定参数😎
如果绑定时第一个参数传入的是函数指针,但后续传入要绑定的参数列表依次是 placeholders::_1和 placeholders::_2,表示后续调用新生成的可调用对象时,传入的第一个参数传给placeholders::_1,传入的第二个参数传给placeholders::_2。
此时绑定后生成的可调用对象的传参方式,和原来没绑定的可调用对象是一样的,所以下面这种就是一个无意义的绑定:
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::_2 设置为 10,意味着 Plus 的第二个参数固定绑定成立 10,调用绑定后的函数时就只需要传入一个参数,它会将该参数与 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;
}
调整传参顺序😎
对于 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 个参数的传递位置
其意义就是:将一个函数的某些参数绑定为固定的值,在调用时可以不用传递某些参数,并且可以对参数顺序进行灵活调整
aqa 芭蕾 eqe 亏内,代表着开心代表着快乐,ok 了家人们