C++ Lambda 表达式 匿名函数 sort

C++ Lambda 表达式（匿名函数）

C++11 开始正式支持 Lambda 表达式 ，本质也是匿名函数 ，可以就地定义、就地使用，不用单独写函数名，非常适合临时用一次的简单逻辑。

它比 Python 的 lambda 功能更强，能捕获外部变量、修改值、配合 STL 算法使用。

---

一、基础语法（最常用）

// 最简格式
[捕获列表] (参数列表) -> 返回值类型 { 函数体 }

拆解释义：

1. [] 捕获列表（必须写）：用来"抓"外部的变量
2. () 参数列表：和普通函数参数一样
3. -> type 返回值类型：简单场景可省略
4. {} 函数体：写逻辑代码

---

二、最简单示例（无参数、无捕获）

#include <iostream>
using namespace std;

int main() {
    // 定义一个 lambda 并立即执行
    []() {
        cout << "我是 C++ Lambda" << endl;
    }();  // 末尾 () 表示调用

    return 0;
}

输出：

我是 C++ Lambda

---

三、带参数 + 带返回值

// 两数相加
auto add = [](int a, int b) {
    return a + b;  // 自动推导返回 int
};

cout << add(3, 5) << endl;  // 输出 8

也可以显式写返回类型：

auto add = [](int a, int b) -> int {
    return a + b;
};

---

四、最核心功能：捕获外部变量 []

这是 C++ lambda 最强大的地方，可以直接用外面的变量。

1. 值捕获（拷贝，不修改原变量）

int x = 10;

// [=] 捕获所有外部变量（值拷贝）
auto func = [=]() {
    cout << x << endl;  // 可以用 x，但不能改 x
};

2. 引用捕获（可修改原变量）

int x = 10;

// [&] 捕获所有外部变量（引用）
auto func = [&]() {
    x = 20;  // 直接修改外面的 x
};

func();
cout << x << endl;  // 输出 20

3. 只捕获某个变量

int a = 1, b = 2;

// 只捕获 a（值），b 用引用
auto func = [a, &b]() {
    // a = 100; ❌ 不能改
    b = 200;   // ✅ 可以改
};

---

五、C++ Lambda 最常用场景：STL 算法

和 sort、for_each、find_if 搭配，代码极简。

示例 1：排序（按自定义规则）

#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;

int main() {
    vector<int> v = {3,1,4,1,5};

    // 降序排序
    sort(v.begin(), v.end(), [](int a, int b) {
        return a > b;
    });

    for(int x : v) cout << x << " ";
    return 0;
}

输出：

5 4 3 1 1

示例 2：遍历打印

vector<int> v = {1,2,3};
for_each(v.begin(), v.end(), [](int x) {
    cout << x << " ";
});

---

六、必须记住的 4 条规则

1. [] 必须写，哪怕是空的
2. 简单逻辑用 lambda，复杂逻辑用普通函数
3. 值捕获 [=] 不能改外部变量 ，引用捕获 [&] 可以
4. 配合 STL 算法 是 lambda 最香的用法

---

总结

1. C++ Lambda = 匿名函数，C++11 及以上可用
2. 语法：[捕获](参数)->返回值{ 代码 }
3. 核心：能捕获外部变量，比 Python lambda 更强
4. 最佳用途：STL 排序、遍历、过滤 等临时逻辑

需要我给你整理一份 「捕获列表速查表」 吗？一眼看懂 [=]/[&]/[x] 的区别。

这个匿名函数为啥最后还是有函数名了呢

也就是没有函数名调用这个匿名函数的时候就是用（）调用吧

理解正确。

对于sort

---

sort 用的是什么排序？

不是插入排序！

也不是单纯的快排。

C++ 的 std::sort 用的是：

混合排序算法（Introsort 内省排序）

简单说它是：

• 数据量大 → 快速排序（快）
• 数据量小 → 插入排序（更快）
• 递归太深 → 堆排序（防止爆栈）

C++ 标准只要求：时间复杂度 O(n log n)

具体实现各家编译器（MSVC、GCC、Clang）略有不同 ，但都是极高质量的混合排序。

你只要记住：

std::sort 是 C++ 最快、最稳定、最安全的通用排序

比你自己写的冒泡、插入、甚至快排都更稳更快。

---

3. sort 怎么用？（最常用写法）

#include <iostream>
#include <vector>
#include <algorithm>  // sort 在这里
using namespace std;

int main() {
    vector<int> v = {3,1,4,1,5};

    // 默认：从小到大
    sort(v.begin(), v.end());

    for (auto x : v) cout << x << " ";
}

---

4. 配合你刚学的 Lambda 自定义排序

// 从大到小排
sort(v.begin(), v.end(), [](int a, int b) {
    return a > b;
});

这里的 lambda 就是告诉 sort：

你想按什么规则比较两个元素

5. 超级关键：sort 能排什么？

✅ vector

✅ 普通数组

✅ string

✅ deque

❌ 不能排 list （list 有自己的 .sort()）

❌ 不能排 map/set（它们本身有序）

---

6. 你最关心的问题：和插入排序比谁快？

数据量 > 20 个：

sort 吊打插入排序

数据量 10000 个：

• 插入排序：O(n²)` → 很慢
• sort：O(n log n)` → 飞快

所以 C++ 推荐永远用 std::sort

---

终极总结（背会这 4 句）

1. sort 不是容器，是算法函数 （在 <algorithm>）
2. 底层是混合排序（内省排序），不是单纯插入/快排
3. 速度极快：O(n log n)
4. 配合 lambda 可以随便自定义排序规则

---

#include <iostream>
#include <vector>
#include <algorithm>  
using namespace std;
int main(){
    vector<int> nums={ 5, 2, 9, 1, 5, 6 };
    sort(nums.begin(),nums.end(),[](int a, int b){return a<b;});
    for(auto x:nums)cout<< x<<" ";

}