std::less 和 std::greater：C++里那个“不写小于号也能比大小”的人

你有没有写过这样的代码？

std::sort(vec.begin(), vec.end(), std::less<int>());

然后心里一愣：std::less<int>() 不就是个空括号吗？它到底干了啥？
不是直接写 std::sort(vec.begin(), vec.end()) 就行了吗？为啥还要多此一举？

这问题背后，藏着 C++ 标准库一个被严重低估的设计细节——函数对象（function object）的显式语义表达力。

std::less 和 std::greater 看似只是“带括号的比较操作符”，但它们的真实价值，不在“能不能用”，而在“为什么值得显式用”。

先说结论：它们不是语法糖，而是类型化比较契约。

std::less<int> 是一个类型，实例化后是一个可调用对象，其 operator() 内部确实调用 <；同理，std::greater<int> 调用 >。但关键在于：这个类型携带了明确的、可推导的、可传递的语义。

比如，std::map<int, string, std::greater<int>> —— 这里你不是在“让 map 反着排”，而是在声明：“我需要一个按降序组织键的有序关联容器”。编译器据此选择红黑树的插入/查找逻辑，算法库也据此做优化假设（例如 upper_bound 的行为边界）。这种语义是 [](int a, int b) { return a > b; } 这种 lambda 无法提供的——后者只是一段匿名逻辑，类型不可名状，无法被模板元编程识别，也无法参与 traits 推导。

再看一个容易踩坑的场景：自定义类型 + 容器适配。

假设你写了一个 struct Point { int x, y; };，并希望 std::set<Point> 按字典序升序排列：

struct Point {
    int x, y;
    bool operator<(const Point& rhs) const { 
        return x < rhs.x || (x == rhs.x && y < rhs.y); 
    }
};
std::set<Point> s; // ✅ 隐式用 operator<

一切正常。但某天你想换成交叉排序：先按 y 升序，再按 x 降序。你改写 operator<？不行——那会破坏原有语义，且其他代码可能依赖旧逻辑。

这时，std::less 就派不上用场了，但 std::greater 也帮不上忙——因为它们只对内置类型或支持 </> 的类型有效。真正该出场的是：自定义函数对象类型，而 std::less/std::greater 正是它的设计范本：

struct ByYAscXDesc {
    bool operator()(const Point& a, const Point& b) const {
        if (a.y != b.y) return a.y < b.y;
        return a.x > b.x; // 注意：这里用 >
    }
};
std::set<Point, ByYAscXDesc> s;

你看，ByYAscXDesc 的结构，和 std::greater 如出一辙：一个轻量、无状态、可复制、满足 StrictWeakOrdering 的 callable 类型。标准库的 less/greater 就是告诉你：这种类型该怎么长、怎么用、怎么被泛型算法信任。

还有一点常被忽略：函数对象比 lambda 更易复用、更易特化。

比如你要为 std::string_view 做不区分大小写的比较：

struct CiLess {
    bool operator()(std::string_view a, std::string_view b) const {
        return std::lexicographical_compare(
            a.begin(), a.end(), b.begin(), b.end(),
            [](char x, char y) { return std::tolower(x) < std::tolower(y); }
        );
    }
};

std::set<std::string_view, CiLess> dict;

这个 CiLess 可以被多个容器复用，可以专门偏特化（比如 template<> struct std::less<MyType>），甚至能放进命名空间做 ADL 查找。而闭包 lambda？每次定义都是新类型，没法跨作用域复用，更没法偏特化。

std::less<T> 的存在，本质上是在说：“比较”这件事，值得拥有自己的类型身份——就像 std::hash<T> 之于哈希，std::equal_to<T> 之于相等判断。

最后回到开头那个疑问：std::sort(v.begin(), v.end(), std::less<int>()) 到底图啥？

答案很实在：当你需要把“升序”这个意图，从隐式默认变成显式契约时。
比如你在写一个模板函数：

template<typename Cont, typename Comp = std::less<typename Cont::value_type>>
void stable_sort_if_needed(Cont& c, Comp comp = {}) {
    // ...
}

这里 Comp = std::less<...> 不仅是默认值，更是编译期可检测的类型线索——你可以用 std::is_same_v<Comp, std::less<...>> 做分支优化，也可以用 Comp::is_transparent 启用透明比较（C++14 起），让 find("key") 直接接受 const char* 而无需构造 std::string。

这才是 std::less 和 std::greater 的真实分量：它们是泛型接口的锚点，是语义可推导、行为可预测、优化可落地的“比较身份证”。

下次看到空括号，别急着删——想想它背后站着的，是一整套类型驱动的设计哲学。
不是所有比较都得手写 <，但所有清晰的比较意图，都值得一个响亮的名字。