# lexicographical_compare

Category: algorithms | Component type: function

### Prototype

`Lexicographical_compare` is an overloaded name; there are actually two `lexicographical_compare` functions.

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

    template <class InputIterator1, class InputIterator2, class BinaryPredicate>
    bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2,
                                 BinaryPredicate comp);

### Description

`Lexicographical_compare` returns `true` if the range of elements `[first1, last1)` is lexicographically less than the range of elements `[first2, last2)`, and `false` otherwise. Lexicographical comparison means "dictionary" (element-by-element) ordering. That is, `[first1, last1)` is less than `[first2, last2)` if `*first1` is less than `*first2`, and greater if `*first1` is greater than `*first2`. If the two first elements are equivalent then `lexicographical_compare` compares the two second elements, and so on. As with ordinary dictionary order, the first range is considered to be less than the second if every element in the first range is equal to the corresponding element in the second but the second contains more elements.

The two versions of `lexicographical_compare` differ in how they define whether one element is less than another. The first version compares objects using `operator<`, and the second compares objects using a function object `comp`.

### 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 LessThan Comparable.
- `InputIterator2`'s value type is a model of LessThan Comparable.
- If `v1` is an object of `InputIterator1`'s value type and `v2` is an object of `InputIterator2`'s value type, then both `v1 < v2` and `v2 < v1` are defined.

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 and second argument type.
- `InputIterator2`'s value type is convertible to `BinaryPredicate`'s first argument type and second argument type.

### Preconditions

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

### Complexity

Linear. At most `2 * min(last1 - first1, last2 - first2)` comparisons.

### Example

    int main()
    {
      int A1[] = {3, 1, 4, 1, 5, 9, 3};
      int A2[] = {3, 1, 4, 2, 8, 5, 7};
      int A3[] = {1, 2, 3, 4};
      int A4[] = {1, 2, 3, 4, 5};

      const int N1 = sizeof(A1) / sizeof(int);
      const int N2 = sizeof(A2) / sizeof(int);
      const int N3 = sizeof(A3) / sizeof(int);
      const int N4 = sizeof(A4) / sizeof(int);

      bool C12 = lexicographical_compare(A1, A1 + N1, A2, A2 + N2);
      bool C34 = lexicographical_compare(A3, A3 + N3, A4, A4 + N4);

      cout << "A1[] < A2[]: " << (C12 ? "true" : "false") << endl;
      cout << "A3[] < A4[]: " << (C34 ? "true" : "false") << endl;
    }

### Notes

### See also

`equal`, `mismatch`, `lexicographical_compare_3way`, `search`, LessThan Comparable, Strict Weak Ordering, `sort`

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