# std::unreachable_sentinel_t, std::unreachable_sentinel

> C++ Atlas: `cppatlas.com/w/cpp/iterator/unreachable_sentinel_t` | Source: https://en.cppreference.com/w/cpp/iterator/unreachable_sentinel_t | Domain: Iterator | Standards: C++20

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

## Official Specification Summary (cppreference)

```cpp
// 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)

```cpp
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

```cpp
#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_view`](https://en.cppreference.com/w/cpp/ranges/iota_view) (C++20), [`views::iota`](https://en.cppreference.com/w/cpp/ranges/iota_view): a `view` consisting of a sequence generated by repeatedly incrementing an initial value (class template) (customization point object)

---
Attribution: content from https://en.cppreference.com/w/cpp/iterator/unreachable_sentinel_t (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.