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
Definido en el encabezado <algorithm>
(1)
template < class ForwardIt, class T >

void replace ( ForwardIt first, ForwardIt last,

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

void replace_if ( ForwardIt first, ForwardIt last,

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

Reemplaza todos los elementos en el rango [ first , last ) con new_value si cumplen criterios específicos.

1) Reemplaza todos los elementos que son iguales a old_value (utilizando operator == ).
3) Reemplaza todos los elementos para los cuales el predicado p devuelve true .
2,4) Igual que (1,3) , pero ejecutado de acuerdo con la policy .
Estas sobrecargas participan en la resolución de sobrecarga solo si se cumplen todas las siguientes condiciones:

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

(hasta C++20)

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

(desde C++20)

Si * first = new_value es inválido (hasta C++20) new_value no es escribible a first (desde C++20) , el programa está mal formado.

Contenidos

Parámetros

first, last - el par de iteradores que define el rango de elementos a procesar
old_value - el valor de los elementos a reemplazar
policy - la política de ejecución a utilizar
p - predicado unario que retorna ​ true si el valor del elemento debe ser reemplazado.

La expresión p ( v ) debe ser convertible a bool para cada argumento v de tipo (posiblemente const) VT , donde VT es el tipo de valor de ForwardIt , independientemente de la categoría de valor , y no debe modificar v . Por lo tanto, no se permite un tipo de parámetro VT & , ni tampoco VT a menos que para VT un movimiento sea equivalente a una copia (since C++11) . ​

new_value - el valor a utilizar como reemplazo
Requisitos de tipo
-
ForwardIt debe cumplir con los requisitos de LegacyForwardIterator .
-
UnaryPred debe cumplir con los requisitos de Predicate .

Complejidad

Dado N como std:: distance ( first, last ) :

1,2) Exactamente N comparaciones utilizando operator == .
3,4) Exactamente N aplicaciones del predicado p .

Excepciones

Las sobrecargas con un parámetro de plantilla llamado ExecutionPolicy reportan errores de la siguiente manera:

  • Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y ExecutionPolicy es uno de los standard policies , std::terminate es llamado. Para cualquier otro ExecutionPolicy , el comportamiento está definido por la implementación.
  • Si el algoritmo falla al asignar memoria, std::bad_alloc es lanzado.

Notas

Debido a que el algoritmo toma old_value y new_value por referencia, puede tener un comportamiento inesperado si cualquiera de ellos es una referencia a un elemento del rango [ first , last ) .

Macro de prueba de características Valor Estándar Característica
__cpp_lib_algorithm_default_value_type 202403 (C++26) Inicialización por lista para algoritmos ( 1-4 )

Implementación posible

reemplazar (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;
}
reemplazar_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;
}

Ejemplo

Ejecutar este código 
#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};
    // Reemplazar todas las ocurrencias de 8 con 88.
    std::replace(s.begin(), s.end(), 8, 88);
    println(s);
    // Reemplazar todos los valores menores que 5 con 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);
}

Salida: 

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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 283 C++98 T se requería que fuera CopyAssignable (y EqualityComparable
para replace ), pero el tipo de valor de ForwardIt no es
siempre T y T no siempre es escribible en ForwardIt 		se requiere que * first = new_value
sea válido en su lugar

Véase también

copia un rango, reemplazando elementos que cumplen criterios específicos con otro valor
(plantilla de función)
(C++20) (C++20)
reemplaza todos los valores que cumplen criterios específicos con otro valor
(objeto función de algoritmo)