std::forward_list<T,Allocator>::unique
void unique();
|
(1) | (depuis C++11) (jusqu'à C++20) |
size_type unique();
|
(depuis C++20) | |
template< class BinaryPredicate >
void unique( BinaryPredicate p );
|
(2) | (depuis C++11) (jusqu'à C++20) |
template< class BinaryPredicate >
size_type unique( BinaryPredicate p );
|
(depuis C++20) | |
Supprime tous les consécutifs doublons 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 | Std | Fonctionnalité |
|---|---|---|---|
__cpp_lib_list_remove_return_type
|
201806L
|
(C++20) | Modifier le type de retour |
Exemple
#include <iostream>
#include <forward_list>
std::ostream& operator<< (std::ostream& os, const std::forward_list<int>& 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 consécutifs en double dans une plage (modèle de fonction & objet de fonction d'algorithme) | |
(C++20) |