std:: unique_copy

Copie les éléments de la plage [ first , last ) vers une autre plage commençant à d_first de telle manière qu'il n'y ait pas d'éléments égaux consécutifs. Seul le premier élément de chaque groupe d'éléments égaux est copié.

Si * d_first = * first est invalide (jusqu'à C++20) * first n'est pas accessible en écriture vers d_first (depuis C++20) , le programme est mal formé.

Si les plages source et destination se chevauchent, le comportement est indéfini.

Étant donné T comme type de valeur de InputIt , si la surcharge (1) ou (3) ne satisfait pas à toutes les conditions suivantes, le comportement est indéfini :

• T est à la fois CopyConstructible et CopyAssignable .
• Toutes les conditions suivantes sont satisfaites :

• OutputIt satisfait aux exigences de LegacyForwardIterator .
• Le type de valeur de OutputIt est également T .
• T est CopyAssignable .

Paramètres

Valeur de retour

Itérateur de sortie vers l'élément situé après le dernier élément écrit.

Complexité

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

Pour les surcharges (2,4) , il peut y avoir un coût de performance si le type de valeur de ForwardIt1 n'est pas à la fois CopyConstructible et CopyAssignable .

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é. 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é.

Implémentation possible

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

Notes

Si InputIt satisfait LegacyForwardIterator , cette fonction relit l'entrée afin de détecter les doublons.

Sinon, si OutputIt satisfait LegacyForwardIterator , et que le type de valeur de InputIt est le même que celui de OutputIt , cette fonction compare * d_first à * first .

Sinon, cette fonction compare * first à une copie locale d'élément.

Exemple

#include <algorithm>
#include <iostream>
#include <iterator>
#include <string>
int main()
{
    std::string s1 {"A string with mmmany letters!"};
    std::cout << "Before: " << s1 << '\n';
    std::string s2;
    std::unique_copy(s1.begin(), s1.end(), std::back_inserter(s2),
                     [](char c1, char c2) { return c1 == 'm' && 'm' == c2; });
    std::cout << "After:  " << s2 << '\n';
}

Before: A string with mmmany letters!
After:  A string with many letters!

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