c++学习(lambda+bind)[27]

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++ 标准库中的一个模板类，定义在 头文件中。

function 类型可以用来存储和调用各种类型的可调用对象，包括函数指针、函数对象、成员函数指针和 Lambda 表达式等。

在这个代码中，function 是一个特定的 function 类型实例化，它表示一个接受两个 long long 类型参数并返回 long long 类型结果的函数。

通过包含 头文件，我们可以使用 function 类型来定义变量、参数和返回值，以存储和调用各种类型的可调用对象。

当使用 std::function 存储类成员函数时，需要注意类参数传递的方式。由于成员函数需要一个类对象来调用，因此在使用 std::function 存储类成员函数时，需要将类对象作为参数传递给 std::function 对象。

下面是一个示例代码，演示了如何使用 std::function 存储类成员函数，并正确传递类对象作为参数：

#include 
#include 

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 
#include 

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 
#include 

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 的结果。