Namespaces
Variants

std:: unique_copy

From cppreference.net
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Definiert im Header <algorithm>
template < class InputIt, class OutputIt >
OutputIt unique_copy ( InputIt first, InputIt last, OutputIt d_first ) ;
(1) (constexpr seit C++20)
template < class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >

ForwardIt2 unique_copy ( ExecutionPolicy && policy, ForwardIt1 first,

ForwardIt1 last, ForwardIt2 d_first ) ;
(2) (seit C++17)
template < class InputIt, class OutputIt, class BinaryPred >

OutputIt unique_copy ( InputIt first, InputIt last,

OutputIt d_first, BinaryPred p ) ;
(3) (constexpr seit C++20)
template < class ExecutionPolicy, class ForwardIt1,

class ForwardIt2, class BinaryPred >
ForwardIt2 unique_copy ( ExecutionPolicy && policy,
ForwardIt1 first, ForwardIt1 last,

ForwardIt2 d_first, BinaryPred p ) ;
(4) (seit C++17)

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

1) Elemente werden mit operator == verglichen.
Wenn operator == keine Äquivalenzrelation definiert, ist das Verhalten undefiniert.
3) Elemente werden mit dem gegebenen binären Prädikat p verglichen.
Wenn p keine Äquivalenzrelation definiert, ist das Verhalten undefiniert.
2,4) Gleich wie (1,3) , aber ausgeführt gemäß policy .
Diese Überladungen nehmen nur dann an der Überladungsauflösung teil, wenn alle folgenden Bedingungen erfüllt sind:

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> ist true .

(bis C++20)

std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> ist true .

(seit C++20)

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

Wenn sich Quell- und Zielbereiche überlappen, 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:

(bis C++20)
(seit C++20)

Inhaltsverzeichnis

Parameter

first, last - das Iteratorpaar, das den Quell- Bereich der zu verarbeitenden Elemente definiert
d_first - der Anfang des Zielbereichs
policy - die zu verwendende Ausführungsrichtlinie
p - binäres Prädikat, das ​ true zurückgibt, wenn die Elemente als gleich behandelt werden sollen.

Die Signatur der Prädikatfunktion sollte äquivalent zu Folgendem sein:

bool pred ( const Type1 & a, const Type2 & b ) ;

Obwohl die Signatur keine const & benötigt, darf die Funktion die übergebenen Objekte nicht modifizieren und muss alle Werte des Typs (möglicherweise const) Type1 und Type2 unabhängig von der Wertkategorie akzeptieren können (daher ist Type1 & nicht erlaubt , ebenso wenig wie Type1 , es sei denn, für Type1 ist eine Verschiebung äquivalent zu einer Kopie (seit C++11) ).
Die Typen Type1 und Type2 müssen so beschaffen sein, dass ein Objekt vom Typ InputIt dereferenziert und dann implizit in beide konvertiert werden kann. ​

Typanforderungen
-
InputIt muss die Anforderungen von LegacyInputIterator erfüllen.
-
OutputIt muss die Anforderungen von LegacyOutputIterator erfüllen.
-
ForwardIt1, ForwardIt2 muss die Anforderungen von LegacyForwardIterator erfüllen.

Rückgabewert

Ausgabeiterator auf das Element nach dem letzten geschriebenen Element.

Komplexität

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

1,2) Genau max(0,N-1) Vergleiche unter Verwendung von operator == .
3,4) Genau max(0,N-1) Anwendungen des Prädikats p .

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';
}

Ausgabe:

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.

DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 239 C++98 das Prädikat wurde std:: distance ( first, last ) Mal angewendet ein Mal weniger angewendet
(für nicht-leere Bereiche)
LWG 241 C++98 der Werttyp von InputIt musste nicht CopyConstructible sein bedingt erforderlich
LWG 538 C++98 der Werttyp von InputIt musste nicht CopyAssignable sein bedingt erforderlich
LWG 2439 C++98 der Werttyp von InputIt musste nicht
CopyConstructible sein, falls OutputIt ein LegacyForwardIterator ist
bedingt erforderlich

Siehe auch

findet die ersten zwei benachbarten Elemente, die gleich sind (oder ein gegebenes Prädikat erfüllen)
(Funktions-Template)
entfernt aufeinanderfolgende doppelte Elemente in einem Bereich
(Funktions-Template)
kopiert einen Bereich von Elementen an einen neuen Speicherort
(Funktions-Template)
erstellt eine Kopie eines Elementbereichs ohne aufeinanderfolgende Duplikate
(Algorithmus-Funktionsobjekt)