Namespaces
Variants

std:: replace, std:: replace_if

From cppreference.net
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)
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
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Определено в заголовке <algorithm>
(1)
template < class ForwardIt, class T >

void replace ( ForwardIt first, ForwardIt last,

const T & old_value, const T & new_value ) ;
(constexpr начиная с C++20)
(до 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 ) ;
(начиная с 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 ) ;
(начиная с C++17)
(до 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 ) ;
(начиная с C++26)
(3)
template < class ForwardIt, class UnaryPred, class T >

void replace_if ( ForwardIt first, ForwardIt last,

UnaryPred p, const T & new_value ) ;
(constexpr начиная с C++20)
(до 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 ) ;
(начиная с 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 ) ;
(начиная с C++17)
(до 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 ) ;
(начиная с C++26)

Заменяет все элементы в диапазоне [ first , last ) на new_value если они удовлетворяют определенным критериям.

1) Заменяет все элементы, равные old_value (используя operator == ).
3) Заменяет все элементы, для которых предикат p возвращает true .
2,4) То же, что и (1,3) , но выполняется в соответствии с policy .
Эти перегрузки участвуют в разрешении перегрузки только при выполнении всех следующих условий:

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> является true .

(до C++20)

std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> является true .

(начиная с C++20)

Если * first = new_value некорректен (до C++20) new_value не является writable для first (начиная с C++20) , программа является некорректной.

Содержание

Параметры

first, last - пара итераторов, определяющих диапазон обрабатываемых элементов
old_value - значение элементов для замены
policy - политика выполнения execution policy для использования
p - унарный предикат, который возвращает ​ true если значение элемента должно быть заменено.

Выражение p ( v ) должно быть преобразуемо в bool для каждого аргумента v типа (возможно const) VT , где VT - тип значения ForwardIt , независимо от категории значения , и не должно изменять v . Таким образом, тип параметра VT & не допускается , как и VT , за исключением случаев, когда для VT перемещение эквивалентно копированию (since C++11) . ​

new_value - значение для использования в качестве замены
Требования к типам
-
ForwardIt должен удовлетворять требованиям LegacyForwardIterator .
-
UnaryPred должен удовлетворять требованиям Predicate .

Сложность

Дано N как std:: distance ( first, last ) :

1,2) Ровно N сравнений с использованием operator == .
3,4) Ровно N применений предиката p .

Исключения

Перегрузки с параметром шаблона с именем ExecutionPolicy сообщают об ошибках следующим образом:

  • Если выполнение функции, вызванной как часть алгоритма, выбрасывает исключение и ExecutionPolicy является одним из стандартных политик , std::terminate вызывается. Для любой другой ExecutionPolicy поведение определяется реализацией.
  • Если алгоритму не удается выделить память, std::bad_alloc выбрасывается.

Примечания

Поскольку алгоритм принимает old_value и new_value по ссылке, это может привести к непредсказуемому поведению, если любой из них является ссылкой на элемент диапазона [ first , last ) .

Макрос тестирования возможностей Значение Стандарт Возможность
__cpp_lib_algorithm_default_value_type 202403 (C++26) Списковая инициализация для алгоритмов ( 1-4 )

Возможная реализация

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;
}
**Примечание:** Весь код C++ внутри тегов `
` и `` оставлен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинале. Переведены только текстовые элементы вне кодовых блоков.

Пример

#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};
    // Заменить все вхождения 8 на 88.
    std::replace(s.begin(), s.end(), 8, 88);
    println(s);
    // Заменить все значения меньше 5 на 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);
}

Вывод:

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

Отчёты о дефектах

Следующие отчеты об изменениях в поведении, содержащие описания дефектов, были применены ретроактивно к ранее опубликованным стандартам C++.

DR Applied to Behavior as published Correct behavior
LWG 283 C++98 T требовался быть CopyAssignable EqualityComparable
для replace ), но тип значения ForwardIt не всегда
является T и T не всегда может быть записан в ForwardIt
требуется, чтобы * first = new_value
был валидным вместо этого

Смотрите также

копирует диапазон, заменяя элементы, удовлетворяющие определённым критериям, другим значением
(function template)
заменяет все значения, удовлетворяющие определённым критериям, другим значением
(algorithm function object)