Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::forward_list
Member functions
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
Deduction guides (C++17)
(1)
void unique ( ) ;
(depuis C++11)
(jusqu'à C++20)
size_type unique ( ) ;
(depuis C++20)
(constexpr depuis C++26)
(2)
template < class BinaryPred >
void unique ( BinaryPred p ) ;
(depuis C++11)
(jusqu'à C++20)
template < class BinaryPred >
size_type unique ( BinaryPred p ) ;
(depuis C++20)
(constexpr depuis C++26)

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

1) Équivalent à unique ( std:: equal_to < T > ( ) ) (jusqu'à C++14) unique ( std:: equal_to <> ( ) ) (depuis C++14) .
2) Utilise p pour comparer les éléments.
Si p n'établit pas une relation d'équivalence, le comportement est indéfini.

Invalide uniquement les itérateurs et les références vers les éléments supprimés.

Table des matières

Paramètres

p - prédicat binaire qui renvoie ​ true si les éléments doivent être traités comme égaux.

La signature de la fonction de prédicat doit être équivalente à ce qui suit :

bool pred ( const Type1 & a, const Type2 & b ) ;

Bien que la signature n'ait pas besoin d'avoir const & , la fonction ne doit pas modifier les objets qui lui sont passés et doit pouvoir accepter toutes les valeurs de type (éventuellement const) Type1 et Type2 indépendamment de la catégorie de valeur (ainsi, Type1 & n'est pas autorisé , ni Type1 sauf si pour Type1 un déplacement équivaut à une copie (depuis C++11) ).
Les types Type1 et Type2 doivent être tels qu'un objet de type forward_list < T,Allocator > :: const_iterator puisse être déréférencé puis implicitement converti vers les deux. ​

Exigences de type
-
BinaryPred doit satisfaire aux exigences de BinaryPredicate .

Valeur de retour

(aucun)

(jusqu'en C++20)

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

(depuis C++20)

Complexité

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

Sinon, étant donné N comme std:: distance ( begin ( ) , end ( ) ) :

1) Exactement N-1 comparaisons en utilisant operator == .
2) Exactement N-1 applications du prédicat p .

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_list_remove_return_type 201806L (C++20) Modifier le type de retour

Exemple

Exécuter ce code 
#include <iostream>
#include <forward_list>
std::ostream& operator<< (std::ostream& os, std::forward_list<int> const& container)
{
    for (int val : container)
        os << val << ' ';
    return os << '\n';
}
int main()
{
    std::forward_list<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";
}

Sortie : 

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

supprime les éléments en double consécutifs dans une plage
(modèle de fonction)