std::ranges:: replace, std::ranges:: replace_if

From cppreference.net

Défini dans l'en-tête `<algorithm>`
Signature d'appel
	(1)
template < std:: input_iterator I, std:: sentinel_for < I > S, class T1, class T2, class Proj = std:: identity > requires std:: indirectly_writable < I, const T2 & > && std:: indirect_binary_predicate < ranges:: equal_to , std :: projected < I, Proj > , const T1 * > constexpr I replace ( I first, S last, const T1 & old_value, const T2 & new_value, Proj proj = { } ) ;			(depuis C++20) (jusqu'à C++26)
template < std:: input_iterator I, std:: sentinel_for < I > S, class Proj = std:: identity , class T1 = std :: projected_value_t < I, Proj > , class T2 = T1 > requires std:: indirectly_writable < I, const T2 & > && std:: indirect_binary_predicate < ranges:: equal_to , std :: projected < I, Proj > , const T1 * > constexpr I replace ( I first, S last, const T1 & old_value, const T2 & new_value, Proj proj = { } ) ;			(depuis C++26)
		(2)
template < ranges:: input_range R, class T1, class T2, class Proj = std:: identity > requires std:: indirectly_writable < ranges:: iterator_t < R > , const T2 & > && std:: indirect_binary_predicate < ranges:: equal_to , std :: projected < ranges:: iterator_t < R > , Proj > , const T1 * > constexpr ranges:: borrowed_iterator_t < R > replace ( R && r, const T1 & old_value, const T2 & new_value, Proj proj = { } ) ;				(depuis C++20) (jusqu'à C++26)
template < ranges:: input_range R, class Proj = std:: identity , class T1 = std :: projected_value_t < ranges:: iterator_t < R > , Proj > , class T2 = T1 > requires std:: indirectly_writable < ranges:: iterator_t < R > , const T2 & > && std:: indirect_binary_predicate < ranges:: equal_to , std :: projected < ranges:: iterator_t < R > , Proj > , const T1 * > constexpr ranges:: borrowed_iterator_t < R > replace ( R && r, const T1 & old_value, const T2 & new_value, Proj proj = { } ) ;				(depuis C++26)
			(3)
template < std:: input_iterator I, std:: sentinel_for < I > S, class T, class Proj = std:: identity , std:: indirect_unary_predicate < std :: projected < I, Proj >> Pred > requires std:: indirectly_writable < I, const T & > constexpr I replace_if ( I first, S last, Pred pred, const T & new_value, Proj proj = { } ) ;					(depuis C++20) (jusqu'à C++26)
template < std:: input_iterator I, std:: sentinel_for < I > S, class Proj = std:: identity , class T = std :: projected_value_t < I, Proj > , std:: indirect_unary_predicate < std :: projected < I, Proj >> Pred > requires std:: indirectly_writable < I, const T & > constexpr I replace_if ( I first, S last, Pred pred, const T & new_value, Proj proj = { } ) ;					(depuis C++26)
				(4)
template < ranges:: input_range R, class T, class Proj = std:: identity , std:: indirect_unary_predicate < std :: projected < ranges:: iterator_t < R > , Proj >> Pred > requires std:: indirectly_writable < ranges:: iterator_t < R > , const T & > constexpr ranges:: borrowed_iterator_t < R > replace_if ( R && r, Pred pred, const T & new_value, Proj proj = { } ) ;						(depuis C++20) (jusqu'à C++26)
template < ranges:: input_range R, class Proj = std:: identity , class T = std :: projected_value_t < ranges:: iterator_t < R > , Proj > , std:: indirect_unary_predicate < std :: projected < ranges:: iterator_t < R > , Proj >> Pred > requires std:: indirectly_writable < ranges:: iterator_t < R > , const T & > constexpr ranges:: borrowed_iterator_t < R > replace_if ( R && r, Pred pred, const T & new_value, Proj proj = { } ) ;						(depuis C++26)

Remplace tous les éléments satisfaisant des critères spécifiques par new_value dans l'intervalle [ first , last ) .

1) Remplace tous les éléments qui sont égaux à old_value , en utilisant std:: invoke ( proj, * i ) == old_value pour comparer.

3) Remplace tous les éléments pour lesquels le prédicat pred s'évalue à true , où l'expression d'évaluation est std:: invoke ( pred, std:: invoke ( proj, * i ) ) .

2,4) Identique à (1,3) , mais utilise r comme plage, comme si on utilisait ranges:: begin ( r ) comme first et ranges:: end ( r ) comme last .

Les entités de type fonction décrites sur cette page sont des objets fonction d'algorithmes (informellement appelés niebloids ), c'est-à-dire :

Les listes d'arguments de modèle explicites ne peuvent pas être spécifiées lors de l'appel de l'une d'entre elles.
Aucune d'entre elles n'est visible pour la recherche dépendante des arguments .
Lorsque l'une d'entre elles est trouvée par la recherche non qualifiée normale comme nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.

Table des matières

Paramètres

first, last	-	la paire itérateur-sentinelle définissant la plage des éléments à traiter
r	-	la plage d'éléments à traiter
old_value	-	la valeur des éléments à remplacer
new_value	-	la valeur à utiliser comme remplacement
pred	-	prédicat à appliquer aux éléments projetés
proj	-	projection à appliquer aux éléments

Valeur de retour

Un itérateur égal à last .

Complexité

Exactement ranges:: distance ( first, last ) applications du prédicat correspondant comp et de toute projection proj .

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,2)

struct replace_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S, class Proj = std::identity,
             class T1 = std::projected_value_t<I, Proj>, class T2 = T1>
    requires std::indirectly_writable<I, const T2&> && 
             std::indirect_binary_predicate
                 <ranges::equal_to, std::projected<I, Proj>, const T1*>
    constexpr I operator()(I first, S last, const T1& old_value,
                           const T2& new_value, Proj proj = {}) const
    {
        for (; first != last; ++first)
            if (old_value == std::invoke(proj, *first))
                *first = new_value;
        return first;
    }
    template<ranges::input_range R, class Proj = std::identity
             class T1 = std::projected_value_t<ranges::iterator_t<R>, Proj>,
             class T2 = T1>
    requires std::indirectly_writable<ranges::iterator_t<R>, const T2&> &&
             std::indirect_binary_predicate<ranges::equal_to,
             std::projected<ranges::iterator_t<R>, Proj>, const T1*>
    constexpr ranges::borrowed_iterator_t<R>
        operator()(R&& r, const T1& old_value,
                   const T2& new_value, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), old_value,
                       new_value, std::move(proj));
    }
};
inline constexpr replace_fn replace{};

replace_if (3,4)

struct replace_if_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S,
             class Proj = std::identity, class T = std::projected_value_t<I, Proj>,
             std::indirect_unary_predicate<std::projected<I, Proj>> Pred>
    requires std::indirectly_writable<I, const T&>
    constexpr I operator()(I first, S last, Pred pred,
                           const T& new_value, Proj proj = {}) const
    {
        for (; first != last; ++first)
            if (!!std::invoke(pred, std::invoke(proj, *first)))
                *first = new_value;
        return std::move(first);
    }
    template<ranges::input_range R, class Proj = std::identity,
             class T = std::projected_value_t<ranges::iterator_t<R>, Proj>
             std::indirect_unary_predicate
                 <std::projected<ranges::iterator_t<R>, Proj>> Pred>
    requires std::indirectly_writable<ranges::iterator_t<R>, const T&>
    constexpr ranges::borrowed_iterator_t<R>
        operator()(R&& r, Pred pred, const T& new_value, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(pred),
                       new_value, std::move(proj));
    }
};
inline constexpr replace_if_fn replace_if{};

Exemple

Exécuter ce code

#include <algorithm>
#include <array>
#include <complex>
#include <iostream>
void println(const auto& v)
{
    for (const auto& e : v)
        std::cout << e << ' ';
    std::cout << '\n';
}
int main()
{
    namespace ranges = std::ranges;
    std::array p{1, 6, 1, 6, 1, 6};
    println(p);
    ranges::replace(p, 6, 9);
    println(p);
    std::array q{1, 2, 3, 6, 7, 8, 4, 5};
    println(q);
    ranges::replace_if(q, [](int x) { return 5 < x; }, 5);
    println(q);
    std::array<std::complex<double>, 2> nums{{{1, 3}, {1, 3}}};
    println(nums);
    #ifdef __cpp_lib_algorithm_default_value_type
        ranges::replace(nums, {1, 3}, {4, 2});
    #else
        ranges::replace(nums, std::complex<double>{1, 3}, std::complex<double>{4, 2});
    #endif
    println(nums);
}

Sortie :

1 6 1 6 1 6
1 9 1 9 1 9
1 2 3 6 7 8 4 5
1 2 3 5 5 5 4 5
(1,3) (1,3)
(4,2) (4,2)

Voir aussi

ranges::replace_copy ranges::replace_copy_if (C++20) (C++20)	copie une plage, en remplaçant les éléments satisfaisant des critères spécifiques par une autre valeur (objet fonction algorithme)
replace replace_if	remplace toutes les valeurs satisfaisant des critères spécifiques par une autre valeur (modèle de fonction)

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants