推荐始终使用 lambda 表达式替代全局函数指针，因其支持值/引用捕获、语义清晰；需满足严格弱序、避免重操作、预计算耗时键值，并用独立比较器解耦多种排序逻辑。
std::sort 传函数对象比传普通函数更安全
直接传全局函数指针给 std::sort 虽然能编译，但一旦函数带捕获（比如要访问局部变量），就只能用 lambda 或仿函数。更关键的是：普通函数无法隐式捕获上下文，容易在多线程或临时对象生命周期结束后出错。
推荐始终使用 lambda 表达式，它天然支持值捕获或引用捕获，语义清晰：
std::vector<std::pair<int, std::string>> data = {{3,"c"}, {1,"a"}, {2,"b"}};
std::sort(data.begin(), data.end(), [](const auto& a, const auto& b) {
return a.first < b.first; // 按 first 升序
});
- lambda 必须是
constexpr友好且无状态的（不捕获时）才能被优化为函数指针；有捕获时会生成闭包类型，std::sort内部按值复制该对象——所以避免在 lambda 中捕获大对象 - 参数务必用
const auto&或具体类型引用，防止不必要的拷贝（尤其对std::string、自定义类） - 返回类型必须是
bool，且逻辑必须满足严格弱序：不能出现a < b和b < a同时为 true，也不能让a < a为 true
自定义结构体排序时 operator< 不够用
很多人给结构体加 operator< 就以为万事大吉，但 std::sort 默认只用它，而实际中常需多种排序逻辑：按时间降序、按名称长度升序、按 flag 分组再按 id 排……这时候硬塞进 operator< 既破坏单一职责，又无法切换。
正确做法是把比较逻辑和数据解耦，用独立的比较器：
立即学习“C++免费学习笔记（深入）”；
struct Person {
std::string name;
int age;
};
// 多种比较器可共存
auto by_age_asc = [](const Person& a, const Person& b) { return a.age < b.age; };
auto by_name_len_desc = [](const Person& a, const Person& b) { return a.name.size() > b.name.size(); };
std::vector<Person> people = {{"Alice", 30}, {"Bob", 25}};
std::sort(people.begin(), people.end(), by_age_asc); // 按年龄升序
std::sort(people.begin(), people.end(), by_name_len_desc); // 按姓名长度降序
- 不要为了省一行代码把 lambda 写成
[&]{...}并在里面修改外部变量——std::sort可能多次调用比较器，行为不可预测 - 如果比较逻辑复杂或复用频繁，定义命名的函数对象（struct +
operator()），比长 lambda 更易测试和调试
std::sort 要求比较器满足严格弱序，否则结果未定义
这是最常被忽略也最危险的一点：一旦比较器返回逻辑错误，std::sort 可能崩溃、死循环，或输出乱序结果，且问题往往只在特定数据集上暴露。
典型错误写法：
// ❌ 错误：用了 != 判断相等性，不满足传递性
[](const int& a, const int& b) { return a % 3 != b % 3; }
// ❌ 错误：浮点数直接用 < 比较，没处理 NaN 或精度问题
[](const double& a, const double& b) { return a < b; } // 若 a 或 b 是 NaN，结果未定义
// ✅ 正确：先处理特殊值，再比较
[](const double& a, const double& b) {
if (std::isnan(a)) return false;
if (std::isnan(b)) return true;
return a < b;
}
- 整数/枚举/字符串等常规类型用
<安全；涉及浮点、指针、自定义资源句柄时，必须显式定义“谁排在谁前面”的完整规则 - 调试时可在比较器里加断言：
assert(!std::isnan(a) && !std::isnan(b));，上线前移除或换为日志
性能敏感场景下，避免在比较器里做重操作
比较器会被调用 O(n log n) 次，哪怕一次调用只慢 100ns，在百万元素排序时也会拖慢上百毫秒。
常见低效模式：
- 在 lambda 里重复调用
std::string::length()或std::vector::size()—— 这些是 O(1)，但仍有函数调用开销；更糟的是调用std::string::find()或std::regex_match() - 每次比较都格式化字符串、解析 JSON 字段、查哈希表
- 用
std::shared_ptr的operator<比较——它比原生指针慢一个数量级
优化建议：
// ❌ 每次都计算
std::sort(v.begin(), v.end(), [](const auto& a, const auto& b) {
return compute_key(a) < compute_key(b); // compute_key 很重
});
// ✅ 预计算 key，再排序（用 index + stable_sort 或 vector<pair<key, ref>>）
std::vector<std::pair<int, size_t>> keyed;
keyed.reserve(v.size());
for (size_t i = 0; i < v.size(); ++i)
keyed.emplace_back(compute_key(v[i]), i);
std::sort(keyed.begin(), keyed.end());
// 然后按 keyed 中的 index 重排 v
很多开发者直到线上排序变慢两倍才意识到比较器里调了一次 std::filesystem::file_size()。真正关键的不是“能不能写”，而是“这一行执行多少次”。 
