lambda
本质：编译器生成一个类
简单的lambda函数
int mian()
{
//两个数相加的lambda
auto add1 = [](int a, int b)->int{return a + b; };
cout << add1(1, 2) << endl;
//省略返回值
auto add2 = [](int a, int b){return a + b; };
cout << add2(1, 2) << endl;
//交换变量的lambda
int x = 0, y = 1;
auto swap1 = [](int& x1, int& x2)->void {int tmp = x1; x1 = x2; x2 = tmp; };
swap1(x, y);
cout << x << ":" << y << endl;
auto swap2 = [](int& x1, int& x2)
{
int tmp = x1;
x1 = x2;
x2 = tmp;
};
swap2(x, y);
cout << x << ":" << y << endl;
//不传参数交换x，y lambda --捕捉列表 (默认捕捉过来的变量不能修改 加mutable)
//auto swap3 = [x, y]()mutable //无修改作用
auto swap3 = [&x, &y]() //传引用捕捉
{
int tmp = x;
x = y;
y = tmp;
};
swap3();
cout << x << ":" << y << endl;
return 0;
}
lambda作为sort的参数（之前用反函数对象或者类型实现）
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._name <
g2._name; });
传值
int mian()
{
int a, b, c, d, e;
a = b = c = d = e = 1;
auto f1 = [=]() { //传值补
cout << a << b << c << d << e << endl;
};
return 0;
//打印不出结果 因为未调用f1
}
下面这样是不允序的，因为a已经是传值补了，不能再定义传值补
auto f2 = [=, a]() {
cout << a << b << c << d << e << endl;
};
正确混合补
auto f2 = [=, &a]() {
a++;
cout << a << b << c << d << e << endl;
};
f1不能被f2赋值因为，f1和f2相当于不同的类，uuid不同，所以不能。可以给函数指针。
力扣150
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<long long> st;
map<string, function<long long(long long, long long)>> opFuncMap =
{
{"+",[](long long a, long long b){return a+b;}},
{"-",[](long long a, long long b){return a-b;}},
{"*",[](long long a, long long b){return a*b;}},
{"/",[](long long a, long long b){return a/b;}}
};
for(auto& str : tokens)
{
if(opFuncMap.count(str)) //操作符
{
long long right = st.top();
st.pop();
long long left=st.top();
st.pop();
st.push(opFuncMap[str](left,right));
}else //操作数
{
st.push(stoll(str));
}
}
return st.top();
}
};
function 类型是 C++ 标准库中的一个模板类，定义在 <functional> 头文件中。
function 类型可以用来存储和调用各种类型的可调用对象，包括函数指针、函数对象、成员函数指针和 Lambda 表达式等。
在这个代码中，function<long long(long long, long long)> 是一个特定的 function 类型实例化，它表示一个接受两个 long long 类型参数并返回 long long 类型结果的函数。
通过包含 <functional> 头文件，我们可以使用 function 类型来定义变量、参数和返回值，以存储和调用各种类型的可调用对象。
当使用 std::function 存储类成员函数时，需要注意类参数传递的方式。由于成员函数需要一个类对象来调用，因此在使用 std::function 存储类成员函数时，需要将类对象作为参数传递给 std::function 对象。
下面是一个示例代码，演示了如何使用 std::function 存储类成员函数，并正确传递类对象作为参数：
#include <iostream>
#include <functional>
class MyClass {
public:
int add(int a, int b) {
return a + b;
}
};
int main() {
MyClass obj;
std::function<int(MyClass&, int, int)> funAdd = &MyClass::add;
int result = funAdd(obj, 3, 4);
std::cout << "Result: " << result << std::endl;
return 0;
}
在上面的示例中，我们定义了一个名为 MyClass 的类，其中包含了一个成员函数 add，用于将两个整数相加并返回结果。然后，我们创建了一个 MyClass 类的对象 obj，并将其作为参数传递给 std::function 对象 funAdd。
通过使用 &MyClass::add 将成员函数的地址赋值给 funAdd，我们可以通过 funAdd 对象来调用 MyClass 类的成员函数 add。在调用 funAdd 时，我们将 obj 对象作为第一个参数传递，后面跟着两个整数参数。
bind绑定
对参数适配的适配器
第一个输出0，第二个输出5
std::bind 是 C++ 标准库中的一个函数模板，用于创建一个新的可调用对象，该对象将指定的函数或成员函数与一组参数绑定在一起。std::bind 可以用于实现参数绑定、参数重排序、固定函数参数等功能。
std::bind 的基本语法如下：
std::bind(func, arg1, arg2, ...)
其中，func 是要绑定的函数或成员函数，arg1, arg2, ... 是要绑定的参数。
下面是一些 std::bind 的使用示例：
示例 1：绑定普通函数
#include <iostream>
#include <functional>
int add(int a, int b) {
return a + b;
}
int main() {
auto add5 = std::bind(add, 5, std::placeholders::_1);
int result = add5(3);
std::cout << "Result: " << result << std::endl;
return 0;
}
在上面的示例中，我们定义了一个名为 add 的普通函数，用于将两个整数相加并返回结果。然后，我们使用 std::bind 将 add 函数与参数 5 绑定在一起，创建了一个新的可调用对象 add5。在调用 add5 时，我们只提供一个参数 3，而 5 是已经绑定的参数。最终，我们将得到 5 + 3 = 8 的结果。
示例 2：绑定成员函数
#include <iostream>
#include <functional>
class MyClass {
public:
int multiply(int a, int b) {
return a * b;
}
};
int main() {
MyClass obj;
auto multiply4 = std::bind(&MyClass::multiply, &obj, std::placeholders::_1);
int result = multiply4(5);
std::cout << "Result: " << result << std::endl;
return 0;
}
在上面的示例中，我们定义了一个名为 MyClass 的类，其中包含了一个成员函数 multiply，用于将两个整数相乘并返回结果。然后，我们创建了一个 MyClass 类的对象 obj，并使用 std::bind 将 multiply 成员函数与参数 &obj 绑定在一起，创建了一个新的可调用对象 multiply4。在调用 multiply4 时，我们只提供一个参数 5，而 &obj 是已经绑定的参数。最终，我们将得到 5 * 4 = 20 的结果。
