std::unique_copy

template< class InputIt, class OutputIt >
OutputIt unique_copy( InputIt first, InputIt last, OutputIt d_first );

template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >
ForwardIt2 unique_copy( ExecutionPolicy&& policy, ForwardIt1 first,
                        ForwardIt1 last, ForwardIt2 d_first );

template< class InputIt, class OutputIt, class BinaryPred >
OutputIt unique_copy( InputIt first, InputIt last,
                      OutputIt d_first, BinaryPred p );

template< class ExecutionPolicy, class ForwardIt1,
          class ForwardIt2, class BinaryPred >
ForwardIt2 unique_copy( ExecutionPolicy&& policy,
                        ForwardIt1 first, ForwardIt1 last,
                        ForwardIt2 d_first, BinaryPred p );

Copie les éléments de la plage [first, last) vers une autre plage commençant à d_first de telle sorte 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 sur 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 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 valeur de OutputIt est aussi 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