C++——C++11（3）

于 2024-03-17 15:35:59 发布
阅读量1k 收藏 19
点赞数 14
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_67693066/article/details/136774974
版权

C++——C++11（3）

我们今天接着来了解一下C++11一些新的特性，如果还没有看过上两次的小伙伴可以点击这里：

https://blog.csdn.net/qq_67693066/article/details/136577386
https://blog.csdn.net/qq_67693066/article/details/136658325

lambda表达式（匿名的仿函数对象）

后期，C++受到了其他语言的影响，风格开始发生了变化，这个lambda表达式就是受了其他语言的影响：

在C++中，lambda表达式（也称为匿名函数）提供了一种方便的方式来定义和使用内联的小函数对象。Lambda表达式特别适用于需要临时函数对象的情况，例如在算法调用（如std::sort、std::find_if等）中作为参数传递。

C++中的lambda表达式的基本语法如下：

[capture](parameters) -> return_type { body_of_lambda }

capture：捕获子句，用于捕获外部作用域的变量，以在lambda函数体内使用。可以是值捕获（通过=）或引用捕获（通过&）。也可以显式列出要捕获的变量。
parameters：lambda函数的参数列表，与常规函数参数列表类似。
return_type：返回类型，通常可以省略，编译器会自动推导返回类型。
body_of_lambda：lambda函数的主体，包含要执行的代码。
注意：
在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

比如我可以用lambda表达式写一个简单的判断偶数的式子：

int main()
{
    vector<int> v1 = {1,2,3,4,5,6,7,8,9,10};

    auto s1 = [v1](int n){ //捕捉v1，参数为n
        if( n % 2 == 0)
        {
            cout<<n<<"是偶数"<<endl; //body_of_lambda
        }
    };

    for(auto e : v1)
    {
        s1(e); //调用s1
    }
}

在这里插入图片描述
我们可以看看s1的类型：

cout << typeid(s1).name() << endl;

在这里插入图片描述
这里class <lambda_741bc9d219826239a4505f712752848a>后面的这串字符串是uuid（通用唯一识别码）然后编译器会生成这么一个类型的仿函数：

我们打个断点，进入到反汇编：
在这里插入图片描述在这里插入图片描述在这里插入图片描述
我们可以通过lambda表达式实现自定义排序：
之前在C++98中如果我们要自定义排序，通常要写一个仿函数：

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}};
    sort(v.begin(), v.end(), ComparePriceGreater()); //使用ComparePriceGreater()匿名对象


    for(auto e: v)
    {
        cout<<e._name << ": " <<e._price <<endl;
    }

    sort(v.begin(), v.end(), ComparePriceLess());
    cout << endl;

    for (auto e : v)
    {
        cout << e._name << ": " << e._price << endl;
    }
}

现在我们有lambda匿名仿函数对象，我们就可以不用写这么多的仿函数了：

    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)
        {return g1._price > g2._price; });


    for (auto e : v)
    {
        cout << e._name << ": " << e._price << endl;
     }

    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)
        {return g1._price < g2._price; }); 
    

    cout << endl;


    for (auto e : v)
    {
        cout << e._name << ": " << e._price << endl;
    }
}

在这里插入图片描述

一些注意点

既然我们可以通过lambda实现一些仿函数的功能，那么我们可以用这个实现一个简单的交换两个变量值的功能：

int main()
{
    int x = 10;
    int y = 19;

    cout << x << " " << y << endl;



    //使用lambda表达式
    auto s1 = [x, y]() {
        int temp;
        temp = x;
        x = y;
        y = temp;
    };

但是这样会报错：
在这里插入图片描述

在这里插入图片描述
那是因为：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
在这里插入图片描述
这下就可以了：

int main()
{
    int x = 10;
    int y = 19;

    cout << x << " " << y << endl;



    //使用lambda表达式
    auto s1 = [x, y]() mutable{
        int temp;
        temp = x;
        x = y;
        y = temp;
    };

    cout << endl;

    s1();

    cout << x << " " << y << endl;
}

这里我们的s1没有传参，是因为捕获列表[]，捕捉到了上面的x，y{}函数体直接使用的是x和y：

我们来运行一下：
在这里插入图片描述发现这里并没有实现交换，估计多半是传的临时对象，我们可以传引用：
在这里插入图片描述
在这里插入图片描述
不仅这样，lambda的捕捉列表给了几种方式：

lambda捕捉列表

[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(包括this)
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(包括this)
[this]：表示值传递方式捕捉当前的this指针

我们来看看[=]和[&]，[this]的玩法：

[=]

[=]：表示值传递方式捕获所有父作用域中的变量(包括this)

int main()
{
    int x = 10;
    int y = 90;

    //lambda表达式 x属于外部变量
    auto lambda = [=]()mutable {
        x += 90;
        y += 90;
        cout << x << " " << y << endl;
    };

    lambda();
    cout << endl;

    //查看数值是否被修改
    cout << x << " " << y << endl;
}

在这里插入图片描述
发现原本的数值没有改变。

[&]

[=]：表示值传递方式捕获所有父作用域中的变量(包括this)

int main()
{
    int x = 10;
    int y = 90;

    //lambda表达式 x属于外部变量
    auto lambda = [&]() {
        x += 90;
        y += 90;
        cout << x << " " << y << endl;
    };

    lambda();
    cout << endl;

    //查看数值是否被修改
    cout << x << " " << y << endl;
}

[this]

[this]：表示值传递方式捕捉当前的this指针

class MyClass {
public:
    int value;

    MyClass(int v) : value(v) {}

    void printValuePlusTen() {
        // 使用 [this] 捕获当前对象的 this 指针  
        auto lambda = [this]() {
            std::cout << this->value + 10 << std::endl;
        };

        lambda(); // 输出 value 的值加 10  
    }
};

int main() 
{
    MyClass obj(5);
    obj.printValuePlusTen(); // 输出: 15  
    cout << obj.value << endl; //输出5
    return 0;
}

在这里插入图片描述
需要注意的是，由于this指针是通过值传递的，因此lambda内部对this指针的拷贝进行操作时，不会影响到原始的this指针或对象本身。

除了这样，还可以混合使用：

语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量
[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量

lambda的赋值

注意一下，就算两个lambda函数的捕获列表，参数，函数体都是一样的，这两个lambda本质上类型不一样，无法互相赋值：

int main()
{
    int x = 10;
    int y = 19;

    cout << x << " " << y << endl;

    //使用lambda表达式
    auto s1 = [&x, &y](){
        int temp;
        temp = x;
        x = y;
        y = temp;
    };

    auto s2 = [&x, &y]() {
        int temp;
        temp = x;
        x = y;
        y = temp;
    };

    s1 = s2;

}

会报错：
在这里插入图片描述在这里插入图片描述

function包装器

现在我们学习了lambda，现在我们调用一个函数有多种方法了：
函数指针，仿函数，lambda，这有时候方法多了，用法就会混，有没有什么方法可以将他们统一起来呢？

C++11中引入了function：

function 是 C++ 标准库 头文件中定义的一个模板类，它包装了任何可调用的目标（函数、lambda 表达式、函数对象等），允许你以一种统一的方式来存储和调用它们。std::function 的一个关键特性是其类型擦除（type erasure）能力，这意味着你可以使用同一个 std::function 对象来存储不同类型的可调用对象，只要它们具有兼容的调用签名。

举个例子：

//函数指针
void Swap_fuc(int& r1, int& r2)
{
    int temp = r1;
    r1 = r2;
    r2 = temp;
}

//仿函数
struct Swap
{
    void operator()(int& r1,int& r2)
    {
        int temp = r1;
        r1 = r2;
        r2 = temp;
    }
};

int main()
{
    //lambda表达式
    auto s1 = [](int& r1, int& r2) {
        int temp = r1;
        r1 = r2;
        r2 = temp;
    };
}

function可以将这三个很好的结合起来：

#include<functional>
//函数指针
void Swap_fuc(int& r1, int& r2)
{
    int temp = r1;
    r1 = r2;
    r2 = temp;
}

//仿函数
struct Swap
{
    void operator()(int& r1,int& r2)
    {
        int temp = r1;
        r1 = r2;
        r2 = temp;
    }
};

int main()
{
    //lambda表达式
    auto s1 = [](int& r1, int& r2) {
        int temp = r1;
        r1 = r2;
        r2 = temp;
    };

    function<void(int&, int&)> funtion1;


    //接收函数指针
    int r1 = 10;
    int r2 = 90;

    cout << "Swap_fuc交换之前的值：" << endl;
    cout << r1 << " " << r2 << endl;
    funtion1 = Swap_fuc;
    funtion1(r1,r2);

    cout << "交换之后的值：" << endl;
    cout << r1 << " " << r2 << endl;
    cout << endl;

    //仿函数
    cout << "Swap()交换之前的值：" << endl;
    cout << r1 << " " << r2 << endl;
    funtion1 = Swap();
    funtion1(r1, r2);
    cout << "交换之后的值：" << endl;
    cout << r1 << " " << r2 << endl;
    cout << endl;

    //lambda
    cout << "lambda交换之前的值：" << endl;
    cout << r1 << " " << r2 << endl;
    funtion1 = s1;
    funtion1(r1, r2);
    cout << "交换之后的值：" << endl;
    cout << r1 << " " << r2 << endl;
    cout << endl;

}

在这里插入图片描述

function成员函数的包装

这里注意一下function对成员函数的包装要加上**&**：

class MyClass
{
public:
    void func_1(int& r1)
    {
        cout << "func_1：" << r1 << endl;
    }

    void func_2(int& r2)
    {
        cout << "func_2：" << r2 << endl;
    }
};

int main()
{
    function<void(int&)> s = &MyClass::func_1;
}

但是，会报错：
在这里插入图片描述在这里插入图片描述这个错误信息好像说，类型好像不一样，好像有一个this指针，我们得加上：
在这里插入图片描述这个时候，调用这个函数就会稍微复杂一点：
在这里插入图片描述
在这里插入图片描述
如果嫌弃这样还是过于麻烦，我们可以传对象：
在这里插入图片描述这样还是太过于复杂，有没有什么办法呢，有的，我们有bind：

bind绑定参数

std::bind是C++标准库中的一个功能，它用于将可调用对象（如函数、函数对象或lambda表达式）与参数绑定在一起，生成一个新的可调用对象。对于成员函数，std::bind特别有用，因为它允许你指定一个对象实例来调用该成员函数。

举一个简单的例子：

void Swap(int& r1, int& r2)
{
    int temp = r1;
    r1 = r2;
    r2 = temp;
}

int main()
{
    //function<void(MyClass,int&)> s = &MyClass::func_1;
    //int u = 90;
    //s(MyClass(), u); //传一个匿名对象

    auto NewSwap = bind(&Swap, 20, placeholders::_1);
    int x = 89;
    NewSwap(x);

    cout << x << endl;
}

这里我指定函数是Swap绑定了第一个参数为20，之后placeholders::_1(_2, _3)表示要传的第一个参数，之后会用新绑定的NewSwap这个对象来调用：
在这里插入图片描述
我们可以利用这一点来简化代码：

class MyClass
{
public:
    void func_1(int& r1)
    {
        cout << "func_1：" << r1 << endl;
    }

    void func_2(int& r2)
    {
        cout << "func_2：" << r2 << endl;
    }
};
int main()
{
    //function<void(MyClass,int&)> s = &MyClass::func_1;
    //int u = 90;
    //s(MyClass(), u); //传一个匿名对象

    //auto NewSwap = bind(&Swap, 20, placeholders::_1);
    //int x = 89;
    //NewSwap(x);

    //cout << x << endl;

    function<void(int&)> s = bind(&MyClass::func_1,
        MyClass(), placeholders::_1);
    int x = 89;
    s(x); 
}

在这里插入图片描述

落水 zh
关注
  • 14
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值