std::remove_copy, std::remove_copy_if

Definiert in Header `<algorithm>`
	(1)
template< class InputIt, class OutputIt, class T > OutputIt remove_copy( InputIt first, InputIt last, OutputIt d_first, const T& value );			(constexpr seit C++20) (bis C++26)
template< class InputIt, class OutputIt, class T = typename std::iterator_traits <InputIt>::value_type > constexpr OutputIt remove_copy( InputIt first, InputIt last, OutputIt d_first, const T& value );			(seit C++26)
		(2)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class T > ForwardIt2 remove_copy( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, const T& value );				(seit C++17) (bis C++26)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class T = typename std::iterator_traits <ForwardIt1>::value_type > ForwardIt2 remove_copy( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, const T& value );				(seit C++26)
template< class InputIt, class OutputIt, class UnaryPred > OutputIt remove_copy_if( InputIt first, InputIt last, OutputIt d_first, UnaryPred p );			(3)	(constexpr seit C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class UnaryPred > ForwardIt2 remove_copy_if( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, UnaryPred p );			(4)	(seit C++17)

Kopiert Elemente aus dem Bereich [first, last) in einen anderen Bereich, der bei d_first beginnt, wobei Elemente, die bestimmte Kriterien erfüllen, weggelassen werden.

1) Ignoriert alle Elemente, die gleich value sind (unter Verwendung von operator==).

3) Ignoriert alle Elemente, für die die Prädikatfunktion p true zurückgibt.

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 ist nicht beschreibbar nach d_first(seit C++20), ist das Programm schlecht geformt.

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

[edit] Parameter

first, last	-	das Iteratorpaar, das den Quell-Bereich der zu kopierenden Elemente definiert
d_first	-	der Anfang des Zielbereichs
value	-	der Wert der Elemente, die nicht kopiert werden sollen
policy	-	die Ausführungsrichtlinie, die verwendet werden soll
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.
- `UnaryPred` muss die Anforderungen von Predicate erfüllen.

[edit] Rückgabewert

Iterator auf das Element nach dem letzten kopierten Element.

[edit] Komplexität

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

1,2) Genau

N

Vergleiche mit value unter Verwendung von operator==.

3,4) Genau

N

Anwendungen des Prädikats p.

Für die Überladungen mit einer ExecutionPolicy kann es zu Leistungseinbußen kommen, wenn der value_type von ForwardIt1 nicht MoveConstructible ist.

[edit] 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.

[edit] Mögliche Implementierung

remove_copy (1)

template<class InputIt, class OutputIt,
         class T = typename std::iterator_traits<InputIt>::value_type>
constexpr OutputIt remove_copy(InputIt first, InputIt last,
                               OutputIt d_first, const T& value)
{
    for (; first != last; ++first)
        if (!(*first == value))
            *d_first++ = *first;
    return d_first;
}

remove_copy_if (3)

template<class InputIt, class OutputIt, class UnaryPred>
constexpr OutputIt remove_copy_if(InputIt first, InputIt last,
                                  OutputIt d_first, UnaryPred p)
{
    for (; first != last; ++first)
        if (!p(*first))
            *d_first++ = *first;
    return d_first;
}

[edit] Anmerkungen

Feature-Test-Makro	Wert	Std	Feature
`__cpp_lib_algorithm_default_value_type`	`202403`	(C++26)	Listeninitialisierung für Algorithmen (1,2)

[edit] Beispiel

Führen Sie diesen Code aus

#include <algorithm>
#include <complex>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
 
int main()
{
    // Erase the hash characters '#' on the fly.
    std::string str = "#Return #Value #Optimization";
    std::cout << "before: " << std::quoted(str) << '\n';
 
    std::cout << "after:  \"";
    std::remove_copy(str.begin(), str.end(),
                     std::ostream_iterator<char>(std::cout), '#');
    std::cout << "\"\n";
 
    // Erase {1, 3} value on the fly.
    std::vector<std::complex<double>> nums{{2, 2}, {1, 3}, {4, 8}, {1, 3}};
    std::remove_copy(nums.begin(), nums.end(),
                     std::ostream_iterator<std::complex<double>>(std::cout),
    #ifdef __cpp_lib_algorithm_default_value_type
                     {1, 3}); // T gets deduced
    #else
                     std::complex<double>{1, 3});
    #endif
}

Ausgabe

before: "#Return #Value #Optimization"
after:  "Return Value Optimization"
(2,2)(4,8)

[edit] 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 779	C++98	`T` musste EqualityComparable sein, aber Der Werttyp von `ForwardIt` ist nicht immer `T`	erforderlich d_first = first stattdessen

[edit] Siehe auch

removeremove_if	entfernt Elemente, die bestimmte Kriterien erfüllen (Funktionstemplate) [edit]
copycopy_if (C++11)	Kopiert einen Elementbereich an einen neuen Speicherort (Funktionstempelat) [edit]
partition_copy (C++11)	Kopiert einen Bereich und teilt die Elemente in zwei Gruppen auf (Funktionstemplate) [edit]
ranges::remove_copyranges::remove_copy_if (C++20)(C++20)	Kopiert einen Bereich von Elementen und lässt diejenigen aus, die bestimmte Kriterien erfüllen (Algorithmus-Funktionsobjekt)[edit]

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

cppreference.com

Namensräume

Varianten

Ansichten

Aktionen