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
Défini dans l'en-tête <algorithm>
(1)
template < class ForwardIt, class T >

void replace ( ForwardIt first, ForwardIt last,

const T & old_value, const T & new_value ) ;
(constexpr depuis C++20)
(jusqu'à 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 ) ;
(depuis 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 ) ;
(depuis C++17)
(jusqu'à 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 ) ;
(depuis C++26)
(3)
template < class ForwardIt, class UnaryPred, class T >

void replace_if ( ForwardIt first, ForwardIt last,

UnaryPred p, const T & new_value ) ;
(constexpr depuis C++20)
(jusqu'à 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 ) ;
(depuis 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 ) ;
(depuis C++17)
(jusqu'à 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 ) ;
(depuis C++26)

Remplace tous les éléments dans la plage [ first , last ) par new_value s'ils satisfont des critères spécifiques.

1) Remplace tous les éléments qui sont égaux à old_value (en utilisant operator == ).
3) Remplace tous les éléments pour lesquels le prédicat p renvoie true .
2,4) Identique à (1,3) , mais exécuté selon la policy .
Ces surcharges participent à la résolution de surcharge seulement si toutes les conditions suivantes sont satisfaites :

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

(jusqu'à C++20)

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

(depuis C++20)

Si * first = new_value est invalide (jusqu'en C++20) new_value n'est pas accessible en écriture vers first (depuis C++20) , le programme est mal formé.

Table des matières

Paramètres

first, last - la paire d'itérateurs définissant l'intervalle des éléments à traiter
old_value - la valeur des éléments à remplacer
policy - la politique d'exécution à utiliser
p - prédicat unaire qui renvoie ​ true si la valeur de l'élément doit être remplacée.

L'expression p ( v ) doit être convertible en bool pour chaque argument v de type (éventuellement const) VT , où VT est le type de valeur de ForwardIt , indépendamment de la catégorie de valeur , et ne doit pas modifier v . Ainsi, un type de paramètre VT & n'est pas autorisé , pas plus que VT sauf si pour VT un déplacement est équivalent à une copie (depuis C++11) . ​

new_value - la valeur à utiliser comme remplacement
Exigences de type
-
ForwardIt doit satisfaire aux exigences de LegacyForwardIterator .
-
UnaryPred doit satisfaire aux exigences de Predicate .

Complexité

Étant donné N comme std:: distance ( first, last ) :

1,2) Exactement N comparaisons en utilisant operator == .
3,4) Exactement N applications du prédicat p .

Exceptions

Les surcharges avec un paramètre de modèle nommé ExecutionPolicy signalent les erreurs comme suit :

  • Si l'exécution d'une fonction invoquée dans le cadre de l'algorithme lève une exception et que ExecutionPolicy fait partie des politiques standard , std::terminate est appelée. Pour tout autre ExecutionPolicy , le comportement est défini par l'implémentation.
  • Si l'algorithme ne parvient pas à allouer de la mémoire, std::bad_alloc est levée.

Notes

Parce que l'algorithme prend old_value et new_value par référence, il peut avoir un comportement inattendu si l'un ou l'autre est une référence à un élément de la plage [ first , last ) .

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_algorithm_default_value_type 202403 (C++26) Initialisation par liste pour les algorithmes ( 1-4 )

Implémentation possible

remplacer (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;
}
remplacer_si (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;
}

Exemple

Exécuter ce code 
#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};
    // Remplacer toutes les occurrences de 8 par 88.
    std::replace(s.begin(), s.end(), 8, 88);
    println(s);
    // Remplacer toutes les valeurs inférieures à 5 par 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);
}

Sortie : 

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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement tel que publié Comportement correct
LWG 283 C++98 T devait être CopyAssignable (et EqualityComparable
pour replace ), mais le type de valeur de ForwardIt n'est pas
toujours T et T n'est pas toujours accessible en écriture pour ForwardIt 		requis que * first = new_value
soit valide à la place

Voir aussi

copie une plage en remplaçant les éléments satisfaisant des critères spécifiques par une autre valeur
(modèle de fonction)
(C++20) (C++20)
remplace toutes les valeurs satisfaisant des critères spécifiques par une autre valeur
(objet fonction d'algorithme)