std::equal_range — cppreference.com

De cppreference.com

Déclaré dans l'en-tête `<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)

Renvoie une plage contenant tous les éléments sont égaux à value dans la gamme [first, last) triés. La plage est définie par deux itérateurs, une pointe vers le premier élément qui est au moins' value et que l'autre pointant vers le premier élément' plus que value. Le premier itérateur peut être obtenue avec lower_bound() alternativement, la seconde - avec 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.

La première version utilise operator< de comparer les éléments, la deuxième version utilise la fonction de comparaison donnée 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.

Paramètres

first, last	-	l'éventail des éléments à examiner 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	-	valeur à comparer les éléments d' 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`.

Retourne la valeur

std::pair contenant une paire d'itérateurs définissant l'intervalle désiré, le premier désignant le premier élément qui est au moins' value que la seconde et pointant vers le premier élément' plus grande 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.

S'il n'y a pas d'éléments' pas moins que value, last est retourné comme le premier élément. Même s'il n'y a pas d'éléments' plus que value, last est retourné comme le deuxième élément

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.

Complexité

Logarithmique de la distance entre first et 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.

Mise en œuvre possible

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

Exemple

#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 << ' ';
}

Résultat :

Voir aussi


lower_bound	retourne un itérateur sur le premier élément' pas moins que la valeur donnée 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. (fonction générique) [edit]**

upper_bound	retourne un itérateur sur le premier élément' plus grande qu'une certaine valeur 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. (fonction générique) [edit]**

binary_search	détermine si un élément existe dans une certaine plage 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. (fonction générique) [edit]