std:: unique

Supprime tous les éléments sauf le premier de chaque groupe consécutif d'éléments équivalents de la plage [ first , last ) et retourne un itérateur pointant après le nouveau dernier élément de la plage.

Explication

La suppression s'effectue en décalant les éléments de la plage de telle manière que les éléments à ne pas supprimer apparaissent au début de la plage.

• Le décalage est effectué par copy assignment (until C++11) move assignment (since C++11) .
• L'opération de suppression est stable : l'ordre relatif des éléments non supprimés reste inchangé.
• La séquence sous-jacente de [ first , last ) n'est pas raccourcie par l'opération de suppression. En considérant result comme l'itérateur retourné :

• Tous les itérateurs dans [ result , last ) restent déréférençables .

Paramètres

Valeur de retour

Un ForwardIt vers la nouvelle fin de la plage.

Complexité

Étant donné \(\scriptsize N\) N comme std:: distance ( first, last ) :

Exceptions

Les surcharges avec un paramètre de modèle nommé ExecutionPolicy signalent les erreurs comme suit :

• Si l'exécution d'une fonction invoquée dans le cadre de l'algorithme lève une exception et que ExecutionPolicy fait partie des politiques standard , std::terminate est appelée. Pour tout autre ExecutionPolicy , le comportement est défini par l'implémentation.
• Si l'algorithme ne parvient pas à allouer de la mémoire, std::bad_alloc est levée.

Implémentation possible

Voir également les implémentations dans libstdc++ , libc++ , et MSVC STL .

template<class ForwardIt>
ForwardIt unique(ForwardIt first, ForwardIt last)
{
    if (first == last)
        return last;
    ForwardIt result = first;
    while (++first != last)
        if (!(*result == *first) && ++result != first)
            *result = std::move(*first);
    return ++result;
}

template<class ForwardIt, class BinaryPredicate>
ForwardIt unique(ForwardIt first, ForwardIt last, BinaryPredicate p)
{
    if (first == last)
        return last;
    ForwardIt result = first;
    while (++first != last)
        if (!p(*result, *first) && ++result != first)
            *result = std::move(*first);
    return ++result;
}

Notes

Un appel à unique est généralement suivi d'un appel à la fonction membre erase du conteneur pour supprimer effectivement les éléments du conteneur.

Exemple

#include <algorithm>
#include <iostream>
#include <vector>
int main()
{
    // un vecteur contenant plusieurs éléments dupliqués
    std::vector<int> v{1, 2, 1, 1, 3, 3, 3, 4, 5, 4};
    auto print = [&](int id)
    {
        std::cout << "@" << id << ": ";
        for (int i : v)
            std::cout << i << ' ';
        std::cout << '\n';
    };
    print(1);
    // supprimer les doublons consécutifs (adjacents)
    auto last = std::unique(v.begin(), v.end());
    // v contient maintenant {1 2 1 3 4 5 4 x x x}, où 'x' est indéterminé
    v.erase(last, v.end());
    print(2);
    // tri suivi de unique, pour supprimer tous les doublons
    std::sort(v.begin(), v.end()); // {1 1 2 3 4 4 5}
    print(3);
    last = std::unique(v.begin(), v.end());
    // v contient maintenant {1 2 3 4 5 x x}, où 'x' est indéterminé
    v.erase(last, v.end());
    print(4);
}

@1: 1 2 1 1 3 3 3 4 5 4
@2: 1 2 1 3 4 5 4
@3: 1 1 2 3 4 4 5
@4: 1 2 3 4 5

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.

Voir aussi