std::hive<T,Allocator>::unique

template< class BinaryPredicate = std::equal_to<T> >
size_type unique( BinaryPredicate binary_pred = BinaryPredicate() );

Supprime tous les consécutifs éléments en double du conteneur. Seul le premier élément de chaque groupe d'éléments égaux est conservé.

Plus formellement, pour une hive non vide, efface tous les éléments désignés par l'itérateur i dans la [begin() + 1, end()) pour lesquels p(*i, *(i - 1)) est vrai.

Invalide les références, pointeurs et itérateurs faisant référence aux éléments effacés. Si le dernier élément de *this est effacé, invalide également l'itérateur de fin.

Le comportement est indéfini si le comparateur correspondant n'établit pas une relation d'équivalence.

Paramètres

Valeur de retour

Le nombre d'éléments supprimés.

Complexité

Si empty() est true, aucune comparaison n'est effectuée.

Sinon, étant donné \(\scriptsize N\)N comme std::distance(begin(), end()) :  exactement \(\scriptsize N-1\)N-1 applications du prédicat p.

Exemple

#include <iostream>
#include <hive>

std::ostream& operator<< (std::ostream& os, const std::hive<int>& container)
{
    for (int val : container)
        os << val << ' ';
    return os << '\n';
}

int main()
{
    std::hive<int> c{1, 2, 2, 3, 3, 2, 1, 1, 2};
    std::cout << "Before unique(): " << c;
    const auto count1 = c.unique();
    std::cout << "After unique():  " << c
              << count1 << " elements were removed\n";
    
    c = {1, 2, 12, 23, 3, 2, 51, 1, 2, 2};
    std::cout << "\nBefore unique(pred): " << c;
    
    const auto count2 = c.unique([mod = 10](int x, int y)
    {
        return (x % mod) == (y % mod);
    });
    
    std::cout << "After unique(pred):  " << c
              << count2 << " elements were removed\n";
}

Before unique(): 1 2 2 3 3 2 1 1 2
After unique():  1 2 3 2 1 2
3 elements were removed

Before unique(pred): 1 2 12 23 3 2 51 1 2 2
After unique(pred):  1 2 23 2 51 2
4 elements were removed

Voir aussi