std::equal_range - cppreference.com

De cppreference.com

Definido no cabeçalho `<algorithm>`

`template< class ForwardIt, class T > std::pair<ForwardIt,ForwardIt> equal_range( ForwardIt first, ForwardIt last, const T& value );`	(1)

`template< class ForwardIt, class T, class Compare > std::pair<ForwardIt,ForwardIt> equal_range( ForwardIt first, ForwardIt last, const T& value, Compare comp );`	(2)

Retorna um intervalo contendo todos os elementos iguais a value no [first, last) intervalo classificado. A gama é definida por dois iteradores, um apontador para o primeiro elemento que é não menos do que value e outra que aponta para o primeiro elemento' maiores do que value. O iterador primeira alternativa pode ser obtida com lower_bound(), o segundo - com upper_bound().

Original:

Returns a range containing all elements equal to value in the sorted range [first, last). The range is defined by two iterators, one pointing to the first element that is not less than value and another pointing to the first element greater than value. The first iterator may be alternatively obtained with lower_bound(), the second - with upper_bound().

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

A primeira versão utiliza operator< para comparar os elementos, a segunda versão utiliza a função de comparação dada comp.

Original:

The first version uses operator< to compare the elements, the second version uses the given comparison function comp.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Parâmetros

first, last	-	a gama de elementos para examinar Original: the range of elements to examine The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
value	-	valor a comparar os elementos de Original: value to compare the elements to The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
comp	-	comparison function which returns `true` if the first argument is less than the second. The signature of the comparison function should be equivalent to the following: `bool cmp(const Type1 &a, const Type2 &b);` 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 `ForwardIt` can be dereferenced and then implicitly converted to `Type2`.
Type requirements
-`ForwardIt` must meet the requirements of `ForwardIterator`.

Valor de retorno

std::pair contendo um par de iteradores que definem o intervalo desejado, o primeiro que aponta para o primeiro elemento que é não menos do que value eo segundo apontando para o primeiro elemento' maior do que value.

Original:

std::pair containing a pair of iterators defining the wanted range, the first pointing to the first element that is not less than value and the second pointing to the first element greater than value.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Se não há elementos não menos do que value, last é retornado como o primeiro elemento. Da mesma forma, se não há elementos maior do que value, last é retornado como o segundo elemento

Original:

If there are no elements not less than value, last is returned as the first element. Similarly if there are no elements greater than value, last is returned as the second element

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Complexidade

Logarítmica na distância entre first e last

Original:

Logarithmic in the distance between first and last

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Possível implementação

First version
template<class ForwardIt, class T std::pair<ForwardIt,ForwardIt> equal_range(ForwardIt first, ForwardIt last, const T& value) { return std::make_pair(std::lower_bound(first, last, value), std::upper_bound(first, last, value)); }
Second version
template<class ForwardIt, class T, class Compare> std::pair<ForwardIt,ForwardIt> equal_range(ForwardIt first, ForwardIt last, const T& value, Compare comp); { return std::make_pair(std::lower_bound(first, last, value, comp), std::upper_bound(first, last, value, comp)); }

First version

template<class ForwardIt, class T 
std::pair<ForwardIt,ForwardIt> 
    equal_range(ForwardIt first, ForwardIt last,
                const T& value)
{
    return std::make_pair(std::lower_bound(first, last, value),
                          std::upper_bound(first, last, value));
}

Second version

template<class ForwardIt, class T, class Compare>
std::pair<ForwardIt,ForwardIt> 
    equal_range(ForwardIt first, ForwardIt last,
                const T& value, Compare comp);
{
    return std::make_pair(std::lower_bound(first, last, value, comp),
                          std::upper_bound(first, last, value, comp));
}

Exemplo

#include <algorithm>
#include <vector>
#include <iostream>

struct S
{
    int number;
    char name;

    S ( int number, char name  )
        : number ( number ), name ( name )
    {}

    // only the number is relevant with this comparison
    bool operator< ( const S& s ) const
    {
        return number < s.number;
    }
};


int main()
{
    std::vector<S> vec = { {1,'A'}, {2,'B'}, {2,'C'}, {2,'D'}, {3,'F'}, {4,'G'} };

    S value ( 2, '?' );

    auto p = std::equal_range(vec.begin(),vec.end(),value);

    for ( auto i = p.first; i != p.second; ++i )
        std::cout << i->name << ' ';
}

Saída:

Veja também


lower_bound	retorna um iterador para o primeiro elemento não menos do que o valor dado Original: returns an iterator to the first element not less than the given value The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (modelo de função) [edit]

upper_bound	retorna um iterador para o primeiro elemento' maior do que um determinado valor Original: *returns an iterator to the first element greater* than a certain value The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (modelo de função) [edit]**

binary_search	determina se existe um elemento de um determinado intervalo Original: determines if an element exists in a certain range The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (modelo de função) [edit]