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

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, 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 = { } ) ;			(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 = { } ) ;			(depuis C++26)
		(2)
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 = { } ) ;				(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 = { } ) ;				(depuis C++26)
			(3)
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 = { } ) ;					(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 = { } ) ;					(depuis C++26)
				(4)
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 = { } ) ;						(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 = { } ) ;						(depuis C++26)
Types d'assistance
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 é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 s'évalue à 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 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 template 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

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)

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