# std::ranges::mismatch, std::ranges::mismatch_result

> C++ Atlas: `cppatlas.com/w/cpp/algorithm/ranges/mismatch` | Source: https://en.cppreference.com/w/cpp/algorithm/ranges/mismatch | Domain: Algorithms | Standards: C++20

Returns the first mismatching pair of projected elements from two ranges: one defined by [first1, last1) or r1 and another defined by [first2, last2) or r2.

## Official Specification Summary (cppreference)

```cpp
// Defined in header <algorithm>

// Call signature

template< std::input_iterator I1, std::sentinel_for<I1> S1,
          std::input_iterator I2, std::sentinel_for<I2> S2,
          class Pred = ranges::equal_to,
          class Proj1 = std::identity, class Proj2 = std::identity >
requires std::indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
constexpr mismatch_result<I1, I2>
    mismatch( I1 first1, S1 last1, I2 first2, S2 last2,
              Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {} ); // (1) (since C++20)

template< ranges::input_range R1, ranges::input_range R2,
          class Pred = ranges::equal_to,
          class Proj1 = std::identity, class Proj2 = std::identity >
requires std::indirectly_comparable<
             ranges::iterator_t<R1>, ranges::iterator_t<R2>, Pred, Proj1, Proj2>
constexpr mismatch_result<ranges::borrowed_iterator_t<R1>,
                          ranges::borrowed_iterator_t<R2>>
    mismatch( R1&& r1, R2&& r2, Pred pred = {},
              Proj1 proj1 = {}, Proj2 proj2 = {} ); // (2) (since C++20)

// Helper types

template< class I1, class I2 >
using mismatch_result = ranges::in_in_result<I1, I2>; // (3) (since C++20)
```

Returns the first mismatching pair of projected elements from two ranges: one defined by `[first1,` `last1)` or `r1` and another defined by `[first2,` `last2)` or `r2`.

1) Elements are compared using the given binary predicate `p`.

2) Same as (1), but uses `r` as the source range, as if using `ranges::begin(r)` as `first` and `ranges::end(r)` as `last`.

The function-like entities described on this page are *algorithm function objects* (informally known as *niebloids*), that is:

- Explicit template argument lists cannot be specified when calling any of them.
- None of them are visible to argument-dependent lookup.
- When any of them are found by normal unqualified lookup as the name to the left of the function-call operator, argument-dependent lookup is inhibited.

### Parameters

- `first1, last1` - an iterator-sentinel pair denoting the first range of the elements to compare
- `r1` - the first range of the elements to compare
- `first2, last2` - an iterator-sentinel pair denoting the second range of the elements to compare
- `r2` - the second range of the elements to compare
- `pred` - predicate to apply to the projected elements
- `proj1` - projection to apply to the first range of elements
- `proj2` - projection to apply to the second range of elements

### Return value

`ranges::mismatch_result` with iterators to the first two non-equal elements.

If no mismatches are found when the comparison reaches `last1` or `last2`, whichever happens first, the object holds the end iterator and the corresponding iterator from the other range.

### Complexity

At most `std::min(last1 - first1, last2 - first2)` applications of the predicate and corresponding projections.

### Possible implementation

```cpp
struct mismatch_fn
{
    template<std::input_iterator I1, std::sentinel_for<I1> S1,
             std::input_iterator I2, std::sentinel_for<I2> S2,
             class Pred = ranges::equal_to,
             class Proj1 = std::identity, class Proj2 = std::identity>
    requires std::indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
    constexpr std::mismatch_result<I1, I2>
        operator()(I1 first1, S1 last1, I2 first2, S2 last2,
                   Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const
    {
        for (; first1 != last1 && first2 != last2; ++first1, (void)++first2)
            if (not std::invoke(pred, std::invoke(proj1, *first1),
                                      std::invoke(proj2, *first2)))
                break;

        return {first1, first2};
    }

    template<ranges::input_range R1, ranges::input_range R2,
             class Pred = ranges::equal_to,
             class Proj1 = std::identity, class Proj2 = std::identity>
    requires std::indirectly_comparable<ranges::iterator_t<R1>, ranges::iterator_t<R2>,
                                        Pred, Proj1, Proj2>
    constexpr ranges::mismatch_result<ranges::borrowed_iterator_t<R1>,
                                      ranges::borrowed_iterator_t<R2>>
        operator()(R1&& r1, R2&& r2, Pred pred = {},
                   Proj1 proj1 = {}, Proj2 proj2 = {}) const
    {
        return (*this)(ranges::begin(r1), ranges::end(r1),
                       ranges::begin(r2), ranges::end(r2),
                       std::ref(pred), std::ref(proj1), std::ref(proj2));
    }
};

inline constexpr mismatch_fn mismatch;
```

### Example

This program determines the longest substring that is simultaneously found at the very beginning and at the very end of the given string, in reverse order (possibly overlapping).

```cpp
#include <algorithm>
#include <iostream>
#include <ranges>
#include <string_view>

[[nodiscard]]
constexpr std::string_view mirror_ends(const std::string_view in)
{
    const auto end = std::ranges::mismatch(in, in | std::views::reverse).in1;
    return {in.cbegin(), end};
}

int main()
{
    std::cout << mirror_ends("abXYZba") << '\n'
              << mirror_ends("abca") << '\n'
              << mirror_ends("ABBA") << '\n'
              << mirror_ends("level") << '\n';

    using namespace std::literals::string_view_literals;

    static_assert("123"sv == mirror_ends("123!@#321"));
    static_assert("radar"sv == mirror_ends("radar"));
}
```

Output:

```text
ab
a
ABBA
level
```

### See also

- [`ranges::equal`](https://en.cppreference.com/w/cpp/algorithm/ranges/equal) (C++20): determines if two sets of elements are the same (algorithm function object)
- [`ranges::find`](https://en.cppreference.com/w/cpp/algorithm/ranges/find) (C++20), [`ranges::find_if`](https://en.cppreference.com/w/cpp/algorithm/ranges/find) (C++20), [`ranges::find_if_not`](https://en.cppreference.com/w/cpp/algorithm/ranges/find) (C++20): finds the first element satisfying specific criteria (algorithm function object)
- [`ranges::lexicographical_compare`](https://en.cppreference.com/w/cpp/algorithm/ranges/lexicographical_compare) (C++20): returns `true` if one range is lexicographically less than another (algorithm function object)
- [`ranges::search`](https://en.cppreference.com/w/cpp/algorithm/ranges/search) (C++20): searches for the first occurrence of a range of elements (algorithm function object)
- [`mismatch`](https://en.cppreference.com/w/cpp/algorithm/mismatch): finds the first position where two ranges differ (function template)

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