std::replace_copy, std::replace_copy_if
| Definiert in Header <algorithm> |
||
template< class InputIt, class OutputIt, class T > OutputIt replace_copy( InputIt first, InputIt last, OutputIt d_first, |
(1) | (constexpr seit C++20) |
| template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class T > |
(2) | (seit C++17) |
| (3) | ||
template< class InputIt, class OutputIt, class UnaryPred, class T > OutputIt replace_copy_if |
(constexpr seit C++20) (bis C++26) |
|
| template< class InputIt, class OutputIt, class UnaryPred, class T = typename std::iterator_traits |
(seit C++26) | |
| (4) | ||
| template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class UnaryPred, class T > |
(seit C++17) (bis C++26) |
|
| template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class UnaryPred, class T = typename std::iterator_traits |
(seit C++26) | |
Kopiert die Elemente aus dem Bereich [first, last) in einen anderen Bereich, der bei d_first beginnt, und ersetzt dabei alle Elemente, die bestimmte Kriterien erfüllen, durch new_value.
|
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 eines der Ergebnisse der Ausdrücke *first und new_value nicht in d_first schreibbar ist, ist das Programm ill-formed.
Wenn sich der Quell- und der Zielbereich überschneiden, ist das Verhalten undefiniert.
Inhalt |
[edit] Parameter
| first, last | - | das Iteratorpaar, das den Quell-Bereich der zu kopierenden Elemente definiert |
| d_first | - | der Anfang des Zielbereichs |
| old_value | - | der Wert der zu ersetzenden Elemente |
| policy | - | die Ausführungsrichtlinie, die verwendet werden soll |
| p | - | unäres Prädikat, das true zurückgibt, wenn der Elementwert ersetzt werden soll. Der Ausdruck p(v) muss für jedes Argument |
| new_value | - | der Wert, der als Ersatz 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. | ||
[edit] Rückgabewert
Iterator auf das Element nach dem letzten kopierten Element.
[edit] Komplexität
Gegeben sei N als std::distance(first, last).
[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
ExecutionPolicyeine der Standardrichtlinien ist, wird std::terminate aufgerufen. Für jede andereExecutionPolicyist das Verhalten implementierungsabhängig. - Wenn dem Algorithmus der Speicher zur Neuzuweisung fehlt, wird std::bad_alloc ausgelöst.
[edit] Mögliche Implementierung
| replace_copy (1) |
|---|
template<class InputIt, class OutputIt, class T> OutputIt replace_copy(InputIt first, InputIt last, OutputIt d_first, const T& old_value, const T& new_value) { for (; first != last; ++first) *d_first++ = (*first == old_value) ? new_value : *first; return d_first; } |
| replace_copy_if (3) |
template<class InputIt, class OutputIt, class UnaryPred, class T = typename std::iterator_traits<ForwardIt>::value_type> OutputIt replace_copy_if(InputIt first, InputIt last, OutputIt d_first, UnaryPred p, const T& new_value) { for (; first != last; ++first) *d_first++ = p(*first) ? new_value : *first; return d_first; } |
[edit] Hinweise
| Feature-Test-Makro | Wert | Std | Feature |
|---|---|---|---|
__cpp_lib_algorithm_default_value_type |
202403 |
(C++26) | List-Initialisierung für Algorithmen (3,4) |
[edit] Beispiel
#include <algorithm> #include <complex> #include <iostream> #include <vector> void println(const auto& seq) { for (const auto& e : seq) std::cout << e << ' '; std::cout << '\n'; } int main() { std::vector<short> src{3, 1, 4, 1, 5, 9, 2, 6, 5}; println(src); std::vector<int> dst(src.size()); std::replace_copy_if(src.cbegin(), src.cend(), dst.begin(), [](short n){ return n > 5; }, 0); println(dst); std::vector<std::complex<double>> src2{{1, 3}, {2, 4}, {3, 5}}, dst2(src2.size()); println(src2); #ifdef __cpp_lib_algorithm_default_value_type std::replace_copy_if(src2.cbegin(), src2.cend(), dst2.begin(), [](std::complex<double> z){ return std::abs(z) < 5; }, {4, 2}); // Possible, since the T is deduced. #else std::replace_copy_if(src2.cbegin(), src2.cend(), dst2.begin(), [](std::complex<double> z){ return std::abs(z) < 5; }, std::complex<double>{4, 2}); #endif println(dst2); }
Ausgabe
3 1 4 1 5 9 2 6 5 3 1 4 1 5 0 2 0 5 (1,3) (2,4) (3,5) (4,2) (4,2) (3,5)
[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 283 | C++98 | T musste CopyAssignable (und EqualityComparable fürreplace_copy), aber der Werttyp von InputIt ist nicht immer T |
Anforderung entfernt |
| LWG 337 | C++98 | replace_copy_if verlangte nur, dass InputItdie Anforderungen von LegacyIteratorerfüllt[1] |
korrigiert zu LegacyInputIterator |
- ↑ Der eigentliche Fehler im C++-Standard ist, dass der Template-Parameter
InputIteratorfälschlicherweise alsIteratorspezifiziert wurde. Dies beeinträchtigt die Typanforderungen, da der C++-Standard besagt, dass für die Funktionstemplates in der Algorithmusbibliothek die Template-Typparameter, deren Name mitIteratorendet, die Typanforderungen der entsprechenden Iterator-Kategorien implizieren.
[edit] Siehe auch
| Ersetzt alle Werte, die bestimmte Kriterien erfüllen, durch einen anderen Wert (Funktionstempelat) | |
| entfernt Elemente, die bestimmte Kriterien erfüllen (Funktionstemplate) | |
| (C++20)(C++20) |
Kopiert einen Bereich und ersetzt Elemente, die bestimmte Kriterien erfüllen, durch einen anderen Wert (Algorithmus-Funktionsobjekt) |
