std::upper_bound

From Cppreference

Jump to: navigation, search

Defined in header `<algorithm>`

template< class ForwardIterator, class T > ForwardIterator upper_bound( ForwardIterator first, ForwardIterator last, const T& value );	(1)

template< class ForwardIterator, class T, class Compare > ForwardIterator upper_bound( ForwardIterator first, ForwardIterator last, const T& value, Compare comp );	(2)

Returns an iterator pointing to the first element in the range [first, last) that is greater than value. The first version uses operator< to compare the elements, the second version uses the given comparison function comp.

The signature does not need to have const &, but the function must not modify the objects passed to it.
The type Type1 must be such that an object of type T can be implicitly converted to Type1. The type Type2 must be such that an object of type ForwardIterator can be dereferenced and then implicitly converted to Type2.

[edit] Return value

iterator pointing to the first element that is greater than value, or last if no such element is found.

[edit] Equivalent function

First version

template<class ForwardIterator, class T>
ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
                            const T& value)
{
    ForwardIterator it;
    std::iterator_traits<ForwardIterator>::distance_type count, step;
    count = std::distance(first,last);
 
    while (count > 0) {
        it = first; 
        step = count / 2; 
        std::advance(it, step);
        if (!(value < *it)) {
            first = ++it;
            count -= step + 1;
        } else count = step;
    }
    return first;
}

Second version

template<class ForwardIterator, class T, class Compare>
ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
                            const T& value, Compare comp)
{
    ForwardIterator it;
    std::iterator_traits<ForwardIterator>::distance_type count, step;
    count = std::distance(first,last);
 
    while (count > 0) {
        it = first; 
        step = count / 2;
        std::advance(it, step);
        if (!comp(value, *it)),
            first = ++it;
            count -= step + 1
        } else count = step;
    }
    return first;
}

[edit] Example

[edit] Complexity

logarithmic in the distance between first and last

[edit] See also

equal_range

returns range of elements matching a specific key
(function template)

lower_bound

returns an iterator to the first element not less than the given value
(function template)