std::unique_copy

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Algorithmenbibliothek

Beschränkte Algorithmen und Algorithmen für Bereiche (C++20)
Beschränkte Algorithmen, z.B. ranges::copy, ranges::sort, ...
Ausführungsrichtlinien (C++17)
is_execution_policy (C++17)   execution::seqexecution::parexecution::par_unseqexecution::unseq (C++17)    (C++17)(C++17)(C++20)	execution::sequenced_policyexecution::parallel_policyexecution::parallel_unsequenced_policyexecution::parallel_unsequenced (C++17)(C++17)(C++17)(C++20)
Nicht-modifizierende Sequenzoperationen Stapeloperationen for_each for_each_n (C++17) Suchoperationen all_ofany_ofnone_of (C++11)                (C++11)(C++11) countcount_if mismatch equal findfind_iffind_if_not (C++11) find_end find_first_of adjacent_find search search_n Modifizierende Sequenzoperationen Kopieroperationen copycopy_if (C++11) copy_backward copy_n (C++11) move (C++11) move_backward (C++11) Tauschoperationen swap iter_swap swap_ranges Transformationsoperationen replacereplace_if transform replace_copyreplace_copy_if Generierungsoperationen fill fill_n generate generate_n Entfernungsoperationen removeremove_if unique remove_copyremove_copy_if unique_copy Ordnungsändernde Operationen reverse reverse_copy rotate rotate_copy random_shuffleshuffle (bis C++17)(C++11) shift_leftshift_right (C++20)(C++20) Stichprobenoperationen sample (C++17)	Sortier- und verwandte Operationen Partitionierungsoperationen partition partition_copy (C++11)   stable_partition is_partitioned (C++11) partition_point (C++11) Sortieroperationen sort stable_sort partial_sort partial_sort_copy is_sorted (C++11) is_sorted_until (C++11) nth_element Binäre Suchoperationen (auf partitionierten Bereichen) lower_bound upper_bound equal_range binary_search Mengenoperationen (auf sortierten Bereichen) includes set_union set_intersection set_difference set_symmetric_difference Zusammenführungsoperationen (auf sortierten Bereichen) merge inplace_merge Heapoperationen push_heap pop_heap make_heap sort_heap is_heap (C++11) is_heap_until (C++11) Minimum/Maximum-Operationen max min minmax (C++11) clamp (C++17) max_element min_element minmax_element (C++11) Lexikographische Vergleichsoperationen lexicographical_compare lexicographical_compare_three_way (C++20) Permutationsoperationen next_permutation prev_permutation is_permutation (C++11) C-Bibliothek qsort bsearch
Numerische Operationen
iota (C++11) inner_product adjacent_difference    accumulate reduce (C++17) transform_reduce (C++17)	partial_sum inclusive_scan (C++17)    exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)
Operationen auf uninitialisiertem Speicher
uninitialized_copy uninitialized_move (C++17)    uninitialized_fill uninitialized_copy_n (C++11) uninitialized_move_n (C++17) uninitialized_fill_n	destroy (C++17) destroy_n (C++17) destroy_at (C++17) construct_at (C++20)       uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17)

 

Definiert in 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, so dass keine aufeinanderfolgenden gleichen Elemente vorhanden sind. Nur das erste Element jeder Gruppe von gleichen Elementen wird kopiert.

1) Elemente werden mit operator== verglichen.

Wenn operator== keine Äquivalenzrelation herstellt, ist das Verhalten undefiniert.

3) Elemente werden mit dem gegebenen binären Prädikat p verglichen.

Wenn p keine Äquivalenzrelation herstellt, ist das Verhalten undefiniert.

2,4) Dasselbe wie (1,3), aber ausgeführt gemäß policy.

Diese Überladungen nehmen an der Auflösungsauflösung teil, nur 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 nach d_first schreibbar ist(seit C++20), ist das Programm fehlerhaft.

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

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

InputIt erfüllt die Anforderungen an einen LegacyForwardIterator.	(bis C++20)
InputIt modelliert einen forward_iterator.	(seit C++20)

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

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

Parameter

first, last	-	das Iteratorenpaar, das den Quellbereich von Elementen definiert, die verarbeitet werden sollen
d_first	-	der Anfang des Zielbereichs
policy	-	die Ausführungsrichtlinie, die verwendet werden soll
p	-	binäre Prädikatfunktion, die ​true zurückgibt, wenn die Elemente als gleich behandelt werden sollen. Die Signatur der Prädikatfunktion sollte äquivalent zur folgenden sein:  bool pred(const Type1 &a, const Type2 &b); Obwohl die Signatur nicht zwingend const & haben muss, darf die Funktion die ihr übergebenen Objekte nicht modifizieren und muss alle Werte vom Typ (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 gleichbedeutend mit 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 an LegacyOutputIterator erfüllen.
- ForwardIt1, ForwardIt2 müssen die Anforderungen an LegacyForwardIterator erfüllen.

Rückgabewert

Output-Iterator auf das Element nach dem letzten geschriebenen Element.

Komplexität

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

1,2) Genau \(\scriptsize max(0,N-1)\)max(0,N-1) Vergleiche mittels operator==.

3,4) Genau \(\scriptsize max(0,N-1)\)max(0,N-1) Anwendungen des Prädikats p.

Bei den Überladungen (2,4) kann es zu einem Performance-Verlust kommen, wenn der Werttyp von ForwardIt1 weder CopyConstructible noch CopyAssignable ist.

Ausnahmen

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

• Wenn die Ausführung einer Funktion, die als Teil des Algorithmus aufgerufen wird, eine Ausnahme auslöst und ExecutionPolicy eine der Standardrichtlinien ist, wird std::terminate aufgerufen. Für jede andere ExecutionPolicy ist das Verhalten implementierungsabhängig.
• Wenn dem Algorithmus der Speicher zur Neuzuweisung fehlt, wird std::bad_alloc ausgelöst.

Mögliche Implementierung

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

Hinweise

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

Andernfalls, wenn OutputIt LegacyForwardIterator erfüllt und der Werttyp von InputIt derselbe ist wie der von OutputIt, vergleicht diese Funktion *d_first mit *first.

Andernfalls vergleicht diese Funktion *first mit einer lokalen Kopie des Elements.

Beispiel

Führen Sie diesen Code aus

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

Defect Reports

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	wurde das Prädikat std::distance(first, last) mal angewendet	einmal weniger angewendet (für nicht-leere Bereiche)
LWG 241	C++98	wurde der Werttyp von InputIt nicht als CopyConstructible gefordert	bedingt erforderlich
LWG 538	C++98	wurde der Werttyp von InputIt nicht als CopyAssignable gefordert	bedingt erforderlich
LWG 2439	C++98	wurde der Werttyp von InputIt nicht als CopyConstructible gefordert, wenn OutputIt ein LegacyForwardIterator ist	bedingt erforderlich

Siehe auch

adjacent_find	Findet die ersten beiden benachbarten Elemente, die gleich sind (oder eine gegebene Bedingung erfüllen) (Funktionstempelat)
unique	Entfernt aufeinanderfolgende doppelte Elemente in einem Bereich (Funktionstemplate)
copycopy_if (C++11)	Kopiert einen Elementbereich an einen neuen Speicherort (Funktionstempelat)
ranges::unique_copy (C++20)	Erstellt eine Kopie eines Bereichs von Elementen, die keine aufeinanderfolgenden Duplikate enthält (Algorithmus-Funktionsobjekt)