为何C++ std::min_element采用bool返回仿函数而非C的int？相等场景如何处理？

Great question! Let's break this down into two key parts: why C++ opted for a bool return type instead of C's int, and how equality is handled in this model.

为什么用bool而不是int？ #

First, let's recall how C's comparison functions work—like the one passed to qsort(), which returns an int: negative if the first element should come before the second, zero if they're equal, positive otherwise.

C++ took a different approach because it leans into strict weak ordering as the foundation for most standard library algorithms (think sort(), min_element(), max_element(), etc.). A strict weak ordering requires that the comparison function returns true if and only if the first argument is "less than" the second (i.e., should come before it in the ordered sequence).

Using bool instead of int has several advantages:

• Semantic clarity: A bool makes the intent explicit—this function is answering a yes/no question: "is a less than b?" An int return type can be ambiguous (someone might return 2 instead of 1, which works in C but is semantically messy).
• Type safety: It enforces that the function only returns a boolean value, preventing accidental invalid return values that could break the algorithm's logic. C's int approach allows any integer, which can lead to subtle bugs if the function returns something unexpected.
• Alignment with C++'s design principles: The language prioritizes making code self-documenting and reducing opportunities for error. A bool return type directly maps to the strict weak ordering requirement, so developers are forced to think in terms of "less than" rather than arbitrary integer results.

元素相等时怎么处理？ #

You're right that bool only has two states, but that's intentional. When two elements are equal (neither is less than the other), the comparison function should return false for both comp(a, b) and comp(b, a).

For std::min_element(), here's how this plays out: the algorithm iterates through the range, keeping track of the current smallest element. When it encounters an element equal to the current minimum, the comparison function comp(current_min, new_element) returns false (since current_min isn't less than new_element), and comp(new_element, current_min) also returns false. Since the algorithm only updates the current minimum if the new element is "less than" the current one (i.e., comp(new_element, current_min) returns true), it will leave the first occurrence of the minimum element as the result.

For example, if you have a range [5, 2, 2, 3], std::min_element() will return an iterator pointing to the first 2 in the range. That's because when it checks the second 2 against the first, comp(2, 2) returns false, so no update happens.

This behavior is consistent with the standard library's focus on stability in such operations—when elements are equivalent, the first occurrence is preserved.

内容的提问来源于stack exchange，提问作者Rushikesh