std::ranges::replace_copy, std::ranges::replace_copy_if, std::ranges::replace_copy_result, std::ranges::replace_copy_if_result

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

Copie les éléments de la plage source [first, last) vers la plage de destination commençant à result, en remplaçant tous les éléments satisfaisant des critères spécifiques par new_value. Le comportement est indéfini si les plages source et destination se chevauchent.

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

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

2,4) Identique à (1,3), mais utilise r comme plage source, comme si ranges::begin(r) était utilisé comme first, et ranges::end(r) comme last.

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

Les listes explicites d'arguments de modèle 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'elles est trouvée par une recherche normale non qualifiée en tant que nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.

Paramètres

result

first, last	-	la paire itérateur-sentinelle définissant la plage d'éléments à copier
r	-	la plage d'éléments à copier
-	le début de la plage de destination
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

{ last, result + N } , où

1,3) N = ranges:: distance ( first, last ) ;

2,4) N = ranges:: distance ( r ) .

Complexité

Exactement N applications du prédicat correspondant comp et de toute projection proj .

Implémentation possible

**Note:** Le code C++ n'a pas été traduit car il se trouve dans des balises `

` et contient des termes spécifiques au C++ qui doivent être préservés selon les instructions. Seul le texte environnant aurait été traduit s'il y en avait eu.

replace_copy (1,2)

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

replace_copy_if (3,4)

struct replace_copy_if_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S,
             class O, class T = std::iter_value_t<O>
             class Proj = std::identity,
             std::indirect_unary_predicate<std::projected<I, Proj>> Pred>
    requires std::indirectly_copyable<I, O> && std::output_iterator<O, const T&>
    constexpr ranges::replace_copy_if_result<I, O>
        operator()(I first, S last, O result, Pred pred,
                   const T& new_value, Proj proj = {}) const
    {
        for (; first != last; ++first, ++result)
             *result = std::invoke(pred, std::invoke(proj, *first)) ? new_value : *first;
        return {std::move(first), std::move(result)};
    }
    template<ranges::input_range R, class O, class T = std::iter_value_t<O>
             class Proj = std::identity,
             std::indirect_unary_predicate
                 <std::projected<ranges::iterator_t<R>, Proj>> Pred>
    requires std::indirectly_copyable<ranges::iterator_t<R>, O> &&
             std::output_iterator<O, const T&>
    constexpr ranges::replace_copy_if_result<ranges::borrowed_iterator_t<R>, O>
        operator()(R&& r, O result, Pred pred,
                   const T& new_value, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(result),
                       std::move(pred), new_value, std::move(proj));
    }
};
inline constexpr replace_copy_if_fn replace_copy_if {};

Notes

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 )

Exemple

Exécuter ce code

#include <algorithm>
#include <array>
#include <complex>
#include <iostream>
#include <vector>
void println(const auto rem, const auto& v)
{
    for (std::cout << rem << ": "; const auto& e : v)
        std::cout << e << ' ';
    std::cout << '\n';
}
int main()
{    
    std::vector<int> o;
    std::array p{1, 6, 1, 6, 1, 6};
    o.resize(p.size());
    println("p", p);
    std::ranges::replace_copy(p, o.begin(), 6, 9);
    println("o", o);
    std::array q{1, 2, 3, 6, 7, 8, 4, 5};
    o.resize(q.size());
    println("q", q);
    std::ranges::replace_copy_if(q, o.begin(), [](int x) { return 5 < x; }, 5);
    println("o", o);
    std::vector<std::complex<short>> r{{1, 3}, {2, 2}, {4, 8}};
    std::vector<std::complex<float>> s(r.size());
    println("r", r);
    #ifdef __cpp_lib_algorithm_default_value_type
        std::ranges::replace_copy(r, s.begin(),
                                  {1, 3}, // T1 est déduit
                                  {2.2, 4.8}); // T2 est déduit
    #else
        std::ranges::replace_copy(r, s.begin(),
                                  std::complex<short>{1, 3},
                                  std::complex<float>{2.2, 4.8});
    #endif
    println("s", s);
    std::vector<std::complex<double>> b{{1, 3}, {2, 2}, {4, 8}},
                                      d(b.size());
    println("b", b);
    #ifdef __cpp_lib_algorithm_default_value_type
        std::ranges::replace_copy_if(b, d.begin(),
            [](std::complex<double> z){ return std::abs(z) < 5; },
            {4, 2}); // Possible, car le T est déduit.
    #else
        std::ranges::replace_copy_if(b, d.begin(),
            [](std::complex<double> z){ return std::abs(z) < 5; },
            std::complex<double>{4, 2});
    #endif
    println("d", d);
}

Sortie :

p: 1 6 1 6 1 6
o: 1 9 1 9 1 9
q: 1 2 3 6 7 8 4 5
o: 1 2 3 5 5 5 4 5
r: (1,3) (2,2) (4,8)
s: (2.2,4.8) (2,2) (4,8)
b: (1,3) (2,2) (4,8)
d: (4,2) (4,2) (4,8)

Voir aussi

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

Support du compilateur
Autonome et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support du langage
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion de mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque des ranges (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque de système de fichiers (C++17)
Bibliothèque de support de la concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

fr.cppreference.net

Namespaces

Variants