Namespaces
Variants

std:: replace, std:: replace_if

From cppreference.net
C++
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)
(C++11)
Swap operations
Transformation operations
replace replace_if
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
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Definiert in Header <algorithm>
(1)
template < class ForwardIt, class T >

void replace ( ForwardIt first, ForwardIt last,

const T & old_value, const T & new_value ) ;
(constexpr seit C++20)
(bis C++26)
template < class ForwardIt, class T = typename std:: iterator_traits

< ForwardIt > :: value_type >
constexpr void replace ( ForwardIt first, ForwardIt last,

const T & old_value, const T & new_value ) ;
(seit C++26)
(2)
template < class ExecutionPolicy, class ForwardIt, class T >

void replace ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last,

const T & old_value, const T & new_value ) ;
(seit C++17)
(bis C++26)
template < class ExecutionPolicy, class ForwardIt,

class T = typename std:: iterator_traits
< ForwardIt > :: value_type >
void replace ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last,

const T & old_value, const T & new_value ) ;
(seit C++26)
(3)
template < class ForwardIt, class UnaryPred, class T >

void replace_if ( ForwardIt first, ForwardIt last,

UnaryPred p, const T & new_value ) ;
(constexpr seit C++20)
(bis C++26)
template < class ForwardIt, class UnaryPred,

class T = typename std:: iterator_traits
< ForwardIt > :: value_type > >
constexpr void replace_if ( ForwardIt first, ForwardIt last,

UnaryPred p, const T & new_value ) ;
(seit C++26)
(4)
template < class ExecutionPolicy,

class ForwardIt, class UnaryPred, class T >
void replace_if ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last,

UnaryPred p, const T & new_value ) ;
(seit C++17)
(bis C++26)
template < class ExecutionPolicy,

class ForwardIt, class UnaryPred,
class T = typename std:: iterator_traits
< ForwardIt > :: value_type > >
void replace_if ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last,

UnaryPred p, const T & new_value ) ;
(seit C++26)

Ersetzt alle Elemente im Bereich [ first , last ) durch new_value wenn sie bestimmte Kriterien erfüllen.

1) Ersetzt alle Elemente, die gleich old_value sind (unter Verwendung von operator == ).
3) Ersetzt alle Elemente, für die das Prädikat p den Wert true zurückgibt.
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 * first = new_value ungültig ist (bis C++20) new_value nicht schreibbar zu first ist (seit C++20) , ist das Programm fehlerhaft.

Inhaltsverzeichnis

Parameter

first, last - das Paar von Iteratoren, das den Bereich der zu verarbeitenden Elemente definiert
old_value - der Wert der zu ersetzenden Elemente
policy - die zu verwendende Ausführungsrichtlinie
p - ein unäres Prädikat, das ​ true zurückgibt, wenn der Elementwert ersetzt werden soll.

Der Ausdruck p ( v ) muss für jedes Argument v vom Typ (möglicherweise const) VT in bool konvertierbar sein, wobei VT der Werttyp von ForwardIt ist, unabhängig von der Wertkategorie , und darf v nicht modifizieren. Daher ist ein Parametertyp VT & nicht zulässig , ebenso wenig wie VT , es sei denn, für VT ist eine Verschiebung äquivalent zu einer Kopie (seit C++11) . ​

new_value - der als Ersatz zu verwendende Wert
Typanforderungen
-
ForwardIt muss die Anforderungen von LegacyForwardIterator erfüllen.
-
UnaryPred muss die Anforderungen von Predicate erfüllen.

Komplexität

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

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

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 allozieren kann, wird std::bad_alloc geworfen.

Hinweise

Da der Algorithmus old_value und new_value per Referenz entgegennimmt, kann er unerwartetes Verhalten zeigen, falls einer davon eine Referenz auf ein Element des Bereichs [ first , last ) ist.

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

Mögliche Implementierung

replace (1) 
template<class ForwardIt,
         class T = typename std::iterator_traits<ForwardIt>::value_type>
void replace(ForwardIt first, ForwardIt last,
             const T& old_value, const T& new_value)
{
    for (; first != last; ++first)
        if (*first == old_value)
            *first = new_value;
}
replace_if (3) 
template<class ForwardIt, class UnaryPred,
         class T = typename std::iterator_traits<ForwardIt>::value_type>
void replace_if(ForwardIt first, ForwardIt last,
                UnaryPred p, const T& new_value)
{
    for (; first != last; ++first)
        if (p(*first))
            *first = new_value;
}

Beispiel

Diesen Code ausführen 
#include <algorithm>
#include <array>
#include <complex>
#include <functional>
#include <iostream>
void println(const auto& seq)
{
    for (const auto& e : seq)
        std::cout << e << ' ';
    std::cout << '\n';
}
int main()
{
    std::array<int, 10> s{5, 7, 4, 2, 8, 6, 1, 9, 0, 3};
    // Ersetze alle Vorkommen von 8 durch 88.
    std::replace(s.begin(), s.end(), 8, 88);
    println(s);
    // Ersetze alle Werte kleiner als 5 durch 55.
    std::replace_if(s.begin(), s.end(), 
                    std::bind(std::less<int>(), std::placeholders::_1, 5), 55);
    println(s);
    std::array<std::complex<double>, 2> nums{{{1, 3}, {1, 3}}};
    #ifdef __cpp_lib_algorithm_default_value_type
        std::replace(nums.begin(), nums.end(), {1, 3}, {4, 2});
    #else
        std::replace(nums.begin(), nums.end(), std::complex<double>{1, 3},
                                               std::complex<double>{4, 2});
    #endif
    println(nums);
}

Ausgabe: 

5 7 4 2 88 6 1 9 0 3
5 7 55 55 88 6 55 9 55 55
(4,2), (4,2)

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 sein (und EqualityComparable
für replace ), aber der Werttyp von ForwardIt ist nicht
immer T und T ist nicht immer in ForwardIt schreibbar 		erfordert stattdessen, dass * first = new_value
gültig ist

Siehe auch

kopiert einen Bereich und ersetzt Elemente, die bestimmte Kriterien erfüllen, durch einen anderen Wert
(Funktions-Template)
(C++20) (C++20)
ersetzt alle Werte, die bestimmte Kriterien erfüllen, durch einen anderen Wert
(Algorithmus-Funktionsobjekt)