# std::unreachable_sentinel_t, std::unreachable_sentinel

From cppreference.com
< cpp‎ | iterator

Defined in header `<iterator>` |  |
struct unreachable_sentinel_t; | (1) | (since C++20)
inline constexpr unreachable_sentinel_t unreachable_sentinel{}; | (2) | (since C++20)

1) `unreachable_sentinel_t` is an empty class type that can be used to denote the “upper bound” of an unbounded interval.
2) `unreachable_sentinel` is a constant of type `unreachable_sentinel_t`.

### Non-member functions

operator== (C++20) | compares an `unreachable_sentinel_t` with a value of any `weakly_incrementable` type (function template)

## operator==(std::unreachable_sentinel_t)

template< std::weakly_incrementable I> friend constexpr bool operator==( unreachable_sentinel_t, const I& ) noexcept { return false; } |  | (since C++20)

`unreachable_sentinel_t` can be compared with any `weakly_incrementable` type and the result is always false.

This function template is not visible to ordinary unqualified or qualified lookup, and can only be found by argument-dependent lookup when `std::unreachable_sentinel_t` is an associated class of the arguments.

### Example

Run this code

    #include <algorithm>
    #include <cstddef>
    #include <iostream>
    #include <iterator>

    template<class CharT>
    constexpr std::size_t strlen(const CharT* s)
    {
        return std::ranges::find(s, std::unreachable_sentinel, CharT{}) - s;
    }

    template<class CharT>
    constexpr std::size_t find_first(const CharT* haystack, const CharT* needle)
    {
        const char* needle_end = needle + strlen(needle);
        // search(begin, unreachable_sentinel) is usually more efficient than
        // search(begin, end) due to one less comparison per cycle.
        // But "needle" MUST BE PRESENT in the "haystack", otherwise the call
        // is UB (which is a compile-time error in constexpr context).
        auto found = std::ranges::search(haystack, std::unreachable_sentinel,
                                         needle, needle_end);
        return found.begin() - haystack;
    }

    int main()
    {
        static_assert(strlen("The quick brown fox jumps over a lazy dog.") == 42);
        static_assert(find_first("unsigned short int", "short") == 9);
    //  static_assert(find_first("long int", "float")); // compile-time error
    }

### See also

ranges::iota_viewviews::iota (C++20) | a `view` consisting of a sequence generated by repeatedly incrementing an initial value (class template) (customization point object)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/iterator/unreachable_sentinel_t&oldid=173730"