C++11新特性之lambda、包装器详解

2026-02-25 09:28:38 作者：雾岛听蓝

lambda表达式是一种匿名函数对象,可以定义在函数内部,用于定义轻量级的局部小函数,本文给大家介绍C++11新特性之lambda、包装器的相关知识,感兴趣的朋友跟随小编一起看看吧

lambda

lambda表达式语法

lambda 表达式本质是一个匿名函数对象，可以定义在函数内部，一般用auto或者模板参数定义的对象去接收 lambda 对象
格式：[捕捉列表] (参数列表) -> 返回值类型 {函数体}
- [捕捉列表] ：根据[]来判断接下来的代码是不是lambda函数，捕捉列表为空也不能省略
- (参数列表)：如果不需要参数传递，则可以连同（）一起省略
- -> 返回值类型：没有返回值和返回值类型明确的情况下，也可以省略，由编译器对返回类型进行推导
- {函数体}：在函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量，函数体为空也不能省略
lambda表达式适用于轻量级的局部小函数，不能递归调用

int main()
{
    //一个简单的lambda表达式
    auto add1 = [](int x, int y)->int
        {
            return x + y;
        };
    cout << add1(1, 2) << endl; //3
    //1.捕捉为空也不能省略
    //2.参数为空可以省略
    //3.返回值可以省略，可以通过返回对象自动推导
    //4.函数体不能省略
    auto func1 = []  //省略参数、返回类型
        {
            cout << "hello ssp" << endl;
            return 0;
        };
    func1();    //hello ssp
    int a = 0, b = 1;
    auto swap1 = [](int& x, int& y)  //省略返回类型
        {
            int tmp = x;
            x = y;
            y = tmp;
        };
    swap1(a, b);
    cout << a << ":" << b << endl;  //1:0
    return 0;
}

捕捉列表

lambda默认只能用lambda函数体和参数中的变量，如果想用外层作用域中的变量就需要进行捕捉
第一种捕捉方式：在捕捉列表中显示的传值捕捉或传引用捕捉，捕捉的多个变量用逗号分割。[x,y,&z]表示x和y值捕捉，z引用捕捉
第二种捕捉方式：在捕捉列表中隐式捕捉。在捕捉列表写一个=表示隐式值捕捉，在捕捉列表写一个&表示隐式引用捕捉，这样写的话lambda表达式中用了哪些变量，编译器就会自动捕捉哪些变量，不会全部捕捉
第三种捕捉方式：混合使用隐式捕捉和显示捕捉
- [=,&x]表示其他变量隐式值捕捉，x引用捕捉
- [&,x,y]表示其他变量引用步骤，x和y值捕捉
lambda表达式如果在函数局部域中，捕捉列表可以捕捉lambda位置之前的变量（除了类域，其余都是向上查找），不能捕捉静态变量和全局变量，静态变量和全局变量也不需要捕捉，在lambda表达式中可以直接使用。这也就意味者，lambda表达式如果定义在全局位置，捕捉列表必须为空（一般也不会写到全局）
默认情况下，lambda捕捉列表是被const修饰的，也就是说传值捕捉过来的对象不能修改。mutable加到参数列表的后面可以取消其常量属性。也就是说，使用mutable修饰符后，传值捕捉的对象就可以修改了，但是修改的还是形参对象，不会影响实参。使用该修饰符后，参数列表不可省略（即使参数为空）

int x = 0;
//定义在全局捕捉列表必须为空，因为全局变量不用捕捉就可以用，没有可捕捉的变量
auto func1 = []()
    {
        x++;
    };
int main()
{
    //只能用当前lambda局部域和捕捉的对象和全局对象
    int a = 0, b = 1, c = 2, d = 3;
    auto func1 = [a, &b]    //除了类域，都是向上查找
        {
            //值捕捉的变量不能修改，引用捕捉的变量可以修改
            //a++ //错误
            b++; //会影响外面的b
            int ret = a + b;
            return ret;
        };
    cout << func1() << endl;    //2
    //隐式值捕捉
    //用了哪些变量就捕捉哪些变量
    auto func2 = [=]()
        {
            int ret = a + b + c;
            return ret;
        };
    cout << func2() << endl;    //4
    //隐式引用捕捉
    //用了哪些变量就捕捉哪些变量
    auto func3 = [&]
        {
            a++;
            c++;
            d++;
        };
    func3();
    cout << a << " " << b << " " << c << " " << d << endl;
    //1 2 3 4
    //混合捕捉1
    auto func4 = [&, a, b]
        {
            //a++;
            //b++;
            c++;
            d++;
            return a + b + c + d;
        };
    func4();
    cout << a << " " << b << " " << c << " " << d << endl;
    //1 2 4 5
    //混合捕捉2
    auto func5 = [=, &a, &b]
        {
            a++;
            b++;
            //c++;
            //d++;
            return a + b + c + d;
        };
    func5();
    cout << a << " " << b << " " << c << " " << d << endl;
    //2 3 4 5
    //局部的静态和全局变量不能捕捉，也不需要捕捉
    static int m = 0;
    auto func6 = []
        {
            int ret = x + m;
            return ret;
        };
    //传值捕捉本质是一种拷贝，并且被const修饰了
    //mutable相当于去掉const属性，可以修改了
    //但是修改不会影响外面被捕捉的值，因为是一种拷贝
    auto func7 = [=]()mutable
        {
            a++;
            b++;
            c++;
            d++;
            return a + b + c + d;
        };
    cout << func7() << endl;    //18
    cout << a << " " << b << " " << c << " " << d << endl;
    //3 4 5 6
    return 0;
}

lambda应用

struct Goods
{
    string _name;   //名字
    double _price;  //价格
    int _evaluate;  //评价
    Goods(const char* str, double price, int evaluate)
        :_name(str)
        , _price(price)
        , _evaluate(evaluate)
    {}
};
struct ComparePriceLess
{
    bool operator()(const Goods& gl, const Goods& gr)
    {
        return gl._price < gr._price;
    }
};
struct ComparePriceGreater
{
    bool operator()(const Goods& gl, const Goods& gr)
    {
        return gl._price > gr._price;
    }
};
int main()
{
    vector<Goods> v = { { "苹果", 2.1, 5 }, { "⾹蕉", 3, 4 }, 
    { "橙⼦", 2.2, 3 }, { "菠萝", 1.5, 4 } };
    //类似这样的场景，我们实现仿函数对象或者函数指针支持不同项的比较
    //相对还是比较麻烦的，不写注释也方便理解，那么用lambda就很好用了
    sort(v.begin(), v.end(), ComparePriceLess());
    sort(v.begin(), v.end(), ComparePriceGreater());
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
        return g1._price < g2._price; 
        });
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
        return g1._price > g2._price;
        });
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
        return g1._evaluate < g2._evaluate;
        });
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
        return g1._evaluate > g2._evaluate;
        });
    return 0;
}

lambda的原理

lambda底层是仿函数对象，也就是说我们写了一个lambda之后，编译器会生成一个对应的仿函数的类
lambda参数/返回类型/函数体就是仿函数operator()的参数/返回类型/函数体，lambda的捕捉列表本质是生成的仿函数类的成员变量，也就是说捕捉列表的变量都是lambda类构造函数的实参

包装器

要==#include <functional>==

function

std::function 是一个类模板，也是一个包装器。std::function 的实例对象可以包装存储其他的可调用对象，包括函数指针、仿函数、lambda、blind表达式等，存储的可调用对象成为std::function的目标。若 std::function 不含目标，则称它为空。调用空 std::function 的目标导致抛出 std::bad_function_call 异常
函数指针、仿函数、lambda等可调用对象的类型不同，std::function的优势就是同一类型，对他们进行包装。

#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: 
    Plus(int n=10)
        :_n(n)
    { }
    static int plusi(int a, int b)
    {
        return a + b;
    }
    double plusd(double a, double b)
    {
        return (a + b) * _n;
    }
private:
    int _n;
};
int main()
{
    //包装各种可调用对象,需要参数类型匹配
    function<int(int, int)> f1 = f; //第一个int是返回值类型，(int.int)为参数列表
    function<int(int, int)> f2 = Functor();
    function<int(int, int)> f3 = [](int a, int b) {return a + b; };
    cout << f1(1, 1) << endl;
    cout << f2(1, 1) << endl;
    cout << f3(1, 1) << endl;
    //包装静态成员函数
    //成员函数要指定类域并且前面加&才能获取地址
    //&静态的可加可不加，非静态的必须加&
    function<int(int, int)> f4 = &Plus::plusi;
    cout << f4(1, 1) << endl;
    //包装普通成员函数
    //普通成员函数还有一个隐含的this指针参数，
    //所以绑定时要传对象或者对象的引用或指针过去
    function<double(Plus*, double, double)> f5 = &Plus::plusd;
    Plus pd;    //是用传入的对象去调用函数
    cout << f5(&pd, 1.1, 1.1) << endl;
    function<double(Plus, double, double)> f6 = &Plus::plusd;
    cout << f6(pd, 1.1, 1.1) << endl;
    function<double(Plus&&, double, double)> f7 = &Plus::plusd;
    cout << f7(move(pd), 1.1, 1.1) << endl; //用右值引用
    cout << f7(Plus(), 1.1, 1.1) << endl;   //用匿名对象
    return 0;
}

bind

bind 是一个函数模板，他也是一个可调用对象的包装器，对接受的fn可调用对象进行处理后返回一个可调用对象。
bind可以用来调整参数个数和参数顺序，它也包含在<functional>头文件中
格式：auto newCallable = bind(callable,arg_list);
- newCallable本身是一个可调用对象
- arg_list是一个逗号分割的参数列表，对应给定的callable的参数
- 当我们调用newCallable时，newCallable会调用callable，并传给它arg_list中的参数
arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是占位符，表示newCallable的参数，他们占据了传递给newCallable的参数的位置。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。_1/_2/_3…这些占位符放到placeholders的一个命名空间

class Plus
{
public: 
    Plus(int n=10)
        :_n(n)
    { }
    static int plusi(int a, int b)
    {
        return a + b;
    }
    double plusd(double a, double b)
    {
        return (a + b) * _n;
    }
private:
    int _n;
};
int main()
{
    auto sub1 = bind(Sub, _1, _2);
    cout << sub1(10, 5) << endl;    //50
    //bind本质是返回的一个仿函数对象
    //调整参数顺序（不常用）
    //_1表示第一个实参
    //_2表示第二个实参
    //……
    auto sub2 = bind(Sub, _2, _1);
    cout << sub2(10, 5) << endl;    //-50
    //调整参数个数(常用)
    auto sub3 = bind(Sub, 100, _1); //把a固定为100
    cout << sub3(3) << endl;    //970
    auto sub4 = bind(Sub, _1, 100); //把b固定为100
    cout << sub4(3) << endl;    //-970
    //分别绑死第123个参数
    auto sub5 = bind(SubX, 100, _1, _2);    //100-_1-_2
    cout << sub5(5, 1) << endl;
    auto sub6 = bind(SubX, _1, 100, _2);    //_1-100-_2
    cout << sub6(5, 1) << endl;
    auto sub7 = bind(SubX, _1, _2, 100);    //_1-_2-100
    cout << sub7(5, 1) << endl;
    //成员函数对象进行绑死，就不需要每次传递了
    function<double(Plus&&, double, double)> f6 = &Plus::plusd;
    Plus pd;
    cout << f6(move(pd), 1.1, 1.1) << endl;
    cout << f6(Plus(), 1.1, 1.1) << endl;
    //bind一般用于绑死一些固定参数
    function<double(double, double)> f7 = bind(&Plus::plusd, Plus(), _1, _2);
    cout << f7(1.1, 1.1) << endl;
    return 0;
}

到此这篇关于C++11新特性之lambda、包装器详解的文章就介绍到这了,更多相关C++11 lambda 包装器内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！