# std::less

From cppreference.com
< cpp‎ | utility‎ | functional

Defined in header `<functional>` |  |
template< class T > struct less; |  | (until C++14)
template< class T = void > struct less; |  | (since C++14)

Function object for performing comparisons. Unless specialized, invokes operator< on type `T`.

### Implementation-defined strict total order over pointers

A specialization of `std::less` for any pointer type yields the implementation-defined strict total order, even if the built-in `<` operator does not.

The implementation-defined strict total order is consistent with the partial order imposed by built-in comparison operators (`<=>`, (since C++20)`<`, `>`, `<=`, and `>=`), and consistent among following standard function objects:

- std::less, std::greater, std::less_equal, and std::greater_equal, when the template argument is a pointer type or void (since C++14)

`std::ranges::equal_to`, `std::ranges::not_equal_to`, `std::ranges::less`, `std::ranges::greater`, `std::ranges::less_equal`, `std::ranges::greater_equal`, and std::compare_three_way | (since C++20)

### Specializations

less<void> (C++14) | function object implementing x < y deducing argument and return types (class template specialization)

### Member types

Type | Definition
`result_type` (deprecated in C++17)(removed in C++20) | bool
`first_argument_type` (deprecated in C++17)(removed in C++20) | `T`
`second_argument_type` (deprecated in C++17)(removed in C++20) | `T`

These member types are obtained via publicly inheriting std::binary_function<T, T, bool>. | (until C++11)

### Member functions

operator() | checks whether the first argument is less than the second (public member function)

## std::less::operator()

bool operator()( const T& lhs, const T& rhs ) const; |  | (until C++14)
constexpr bool operator()( const T& lhs, const T& rhs ) const; |  | (since C++14)

Checks whether lhs is less than rhs.

### Parameters

lhs, rhs | - | values to compare

### Return value

For `T` which is not a pointer type, true if lhs < rhs, false otherwise.

For `T` which is a pointer type, true if lhs precedes rhs in the implementation-defined strict total order, false otherwise.

### Exceptions

May throw implementation-defined exceptions.

### Possible implementation

    constexpr bool operator()(const T &lhs, const T &rhs) const
    {
        return lhs < rhs; // assumes that the implementation uses a flat address space
    }

### Example

Run this code

    #include <functional>
    #include <iostream>

    template<typename A, typename B, typename C = std::less<>>
    bool fun(A a, B b, C cmp = C{})
    {
        return cmp(a, b);
    }

    int main()
    {
        std::cout
            << std::boolalpha
            << fun(1, 2)   << ' ' // true
            << fun(1.0, 1) << ' ' // false
            << fun(1, 2.0) << ' ' // true
            << std::less<int>{}(5, 5.6)    << ' ' // false: 5 < 5 (warn: implicit conversion)
            << std::less<double>{}(5, 5.6) << ' ' // true: 5.0 < 5.6
            << std::less<int>{}(5.6, 5.7)  << ' ' // false: 5 < 5 (warn: implicit conversion)
            << std::less{}(5, 5.6)         << ' ' // true: less<void>: 5.0 < 5.6
            << '\n';
    }

Output:

    true false true false true false true

### See also

equal_to | function object implementing x == y (class template)
greater | function object implementing x > y (class template)
ranges::less (C++20) | function object implementing x < y (class)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/utility/functional/less&oldid=152260"