std::list<T,Allocator>::unique
void unique();
|
(1) | (jusqu'à C++20) |
size_type unique();
|
(depuis C++20) | |
template< class BinaryPredicate >
void unique( BinaryPredicate p );
|
(2) | (jusqu'à C++20) |
template< class BinaryPredicate >
size_type unique( BinaryPredicate p );
|
(depuis C++20) | |
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é.
Invalide uniquement les itérateurs et les références aux éléments supprimés.
operator== pour comparer les éléments.p pour comparer les éléments.Le comportement est indéfini si le comparateur correspondant n'établit pas une relation d'équivalence.
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)
|
| 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 ( ) ) :
Notes
| Macro de test de fonctionnalité | Valeur | Norme | Fonctionnalité |
|---|---|---|---|
__cpp_lib_list_remove_return_type
|
201806L
|
(C++20) | Modifier le type de retour |
Exemple
#include <iostream>
#include <list>
std::ostream& operator<< (std::ostream& os, const std::list<int>& container)
{
for (int val : container)
os << val << ' ';
return os << '\n';
}
int main()
{
std::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";
}
Résultat :\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
Rapports de défauts
Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.
| DR | Appliqué à | Comportement tel que publié | Comportement correct |
|---|---|---|---|
| LWG 1207 | C++98 |
il n'était pas clair si les itérateurs
et/ou les références seraient invalidés |
invalide uniquement les itérateurs et
les références vers les éléments supprimés |
Voir aussi
| supprime les éléments dupliqués consécutifs dans une plage (modèle de fonction & objet fonction d'algorithme) | |
(C++20) |