# mismatch

Category: algorithms | Component type: function

### Prototype

`Mismatch` is an overloaded name; there are actually two `mismatch` functions.

    template <class InputIterator1, class InputIterator2>
    pair<InputIterator1, InputIterator2>
    mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);

    template <class InputIterator1, class InputIterator2,
              class BinaryPredicate>
    pair<InputIterator1, InputIterator2>
    mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
             BinaryPredicate binary_pred);

### Description

`Mismatch` finds the first position where the two ranges `[first1, last1)` and `[first2, first2 + (last1 - first1))` differ. The two versions of `mismatch` use different tests for whether elements differ.

The first version of `mismatch` finds the first iterator `i` in `[first1, last1)` such that `*i != *(first2 + (i - first1))`. The return value is a pair whose first element is `i` and whose second element is `*(first2 + (i - first1))`. If no such iterator `i` exists, the return value is a pair whose first element is `last1` and whose second element is `*(first2 + (last1 - first1))`.

The second version of `mismatch` finds the first iterator `i` in `[first1, last1)` such that `binary_pred(*i, *(first2 + (i - first1))` is `false`. The return value is a pair whose first element is `i` and whose second element is `*(first2 + (i - first1))`. If no such iterator `i` exists, the return value is a pair whose first element is `last1` and whose second element is `*(first2 + (last1 - first1))`.

### Definition

Defined in the standard header algorithm, and in the nonstandard backward-compatibility header algo.h.

### Requirements on types

For the first version:

- `InputIterator1` is a model of Input Iterator.
- `InputIterator2` is a model of Input Iterator.
- `InputIterator1`'s value type is a model of Equality Comparable.
- `InputIterator2`'s value type is a model of Equality Comparable.
- `InputIterator1`'s value type can be compared for equality with `InputIterator2`'s value type.

For the second version:

- `InputIterator1` is a model of Input Iterator.
- `InputIterator2` is a model of Input Iterator.
- `BinaryPredicate` is a model of Binary Predicate.
- `InputIterator1`'s value type is convertible to `BinaryPredicate`'s first argument type.
- `InputIterator2`'s value type is convertible to `BinaryPredicate`'s second argument type.

### Preconditions

- `[first1, last1)` is a valid range.
- `[first2, first2 + (last2 - last1))` is a valid range.

### Complexity

Linear. At most `last1 - first1` comparisons.

### Example

    int A1[] = { 3, 1, 4, 1, 5, 9, 3 };
    int A2[] = { 3, 1, 4, 2, 8, 5, 7 };
    const int N = sizeof(A1) / sizeof(int);

    pair<int*, int*> result = mismatch(A1, A1 + N, A2);
    cout << "The first mismatch is in position " << result.first - A1 << endl;
    cout << "Values are: " << *(result.first) << ", " << *(result.second) << endl;

### Notes

### See also

`equal`, `search`, `find`, `find_if`

Copyright © 1999 Silicon Graphics, Inc. All Rights Reserved. TrademarkInformation