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 );

Kopiert die Elemente aus dem Bereich [first, last), beginnend an d_first in einen anderen Bereich, so dass keine aufeinanderfolgenden gleichen Elemente vorhanden sind. Nur das erste Element jeder Gruppe gleicher Elemente wird kopiert.

Wenn *d_first = *first ungültig ist(bis C++20)*first nicht beschreibbar in d_first(seit C++20) ist, ist das Programm fehlerhaft.

Wenn sich Quell- und Zielbereiche überschneiden, ist das Verhalten undefiniert.

Gegeben T als Werttyp von InputIt, wenn Überladung (1) oder (3) nicht alle der folgenden Bedingungen erfüllt, ist das Verhalten undefiniert: nicht

• T ist sowohl CopyConstructible als auch CopyAssignable.
• Alle folgenden Bedingungen sind erfüllt:

• OutputIt erfüllt die Anforderungen von LegacyForwardIterator.
• Der Werttyp von OutputIt ist ebenfalls T.
• T ist CopyAssignable.

Parameter

Rückgabewert

Ausgabeiterator auf das Element nach dem letzten geschriebenen Element.

Komplexität

Gegeben \(\scriptsize N\) N als std:: distance ( first, last ) :

Für Überladungen (2,4) kann es zu Leistungseinbußen kommen, wenn der Werttyp von ForwardIt1 nicht sowohl CopyConstructible als auch CopyAssignable ist.

Ausnahmen

Die Überladungen mit einem Template-Parameter namens ExecutionPolicy melden Fehler wie folgt:

• Wenn die Ausführung einer als Teil des Algorithmus aufgerufenen Funktion eine Exception wirft und ExecutionPolicy einer der Standard-Policies ist, wird std::terminate aufgerufen. Für jede andere ExecutionPolicy ist das Verhalten implementierungsdefiniert.
• Wenn der Algorithmus keinen Speicher allokieren kann, wird std::bad_alloc geworfen.

Mögliche Implementierung

Siehe auch die Implementierungen in libstdc++ und libc++ .

Hinweise

Wenn InputIt die Anforderungen LegacyForwardIterator erfüllt, liest diese Funktion die Eingabe erneut, um Duplikate zu erkennen.

Andernfalls, wenn OutputIt die Anforderungen LegacyForwardIterator erfüllt und der Werttyp von InputIt mit dem von OutputIt übereinstimmt, vergleicht diese Funktion * d_first mit * first .

Andernfalls vergleicht diese Funktion * first mit einer lokalen Elementkopie.

Beispiel

#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!

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch