# equal

Category: algorithms | Component type: function

### Prototype

`Equal` is an overloaded name; there are actually two `equal` functions.

    template <class InputIterator1, class InputIterator2>
    bool equal(InputIterator1 first1, InputIterator1 last1,
               InputIterator2 first2);

    template <class InputIterator1, class InputIterator2,
              class BinaryPredicate>
    bool equal(InputIterator1 first1, InputIterator1 last1,
               InputIterator2 first2, BinaryPredicate binary_pred);

### Description

`Equal` returns `true` if the two ranges `[first1, last1)` and `[first2, first2 + (last1 - first1))` are identical when compared element-by-element, and otherwise returns `false`. [1]

The first version of `equal` returns `true` if and only if for every iterator `i` in `[first1, last1)`, `*i == *(first2 + (i - first1))`. The second version of `equal` returns `true` if and only if for every iterator `i` in `[first1, last1)`, `binary_pred(*i, *(first2 + (i - first1))` is `true`.

### 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);

    cout << "Result of comparison: " << equal(A1, A1 + N, A2) << endl;

### Notes

[1] Note that this is very similar to the behavior of `mismatch`: The only real difference is that while `equal` will simply return `false` if the two ranges differ, `mismatch` returns the first location where they do differ. The expression `equal(f1, l1, f2)` is precisely equivalent to the expression `mismatch(f1, l1, f2).first == l1`, and this is in fact how `equal` could be implemented.

### See also

`mismatch`, `search`, `find`, `find_if`

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