Namespaces
Variants

    std::experimental::ranges:: copy, std::experimental::ranges:: copy_if

    From fr.cppreference.net
    C++
    Experimental
    Ranges
    Algorithms library
    Non-modifying sequence operations
    Modifying sequence operations
    Partitioning operations
    Sorting operations
    Binary search operations
    Set operations (on sorted ranges)
    Heap operations
    Minimum/maximum operations
    Permutations
    **Note:** Le code C++ et les termes techniques n'ont pas été traduits conformément aux instructions, car ils font partie intégrante de la syntaxe du langage de programmation et doivent rester en anglais pour préserver leur signification technique exacte.
    Défini dans l'en-tête <experimental/ranges/algorithm>
    template < InputIterator I, Sentinel < I > S, WeaklyIncrementable O >

    requires IndirectlyCopyable < I, O >
    ranges:: tagged_pair < tag:: in ( I ) , tag:: out ( O ) >

    copy ( I first, S last, O result ) ;
    		(1) (ranges TS)
    template < InputRange R, WeaklyIncrementable O >

    requires IndirectlyCopyable < ranges:: iterator_t < R > , O >
    ranges:: tagged_pair < tag:: in ( ranges:: safe_iterator_t < R > ) , tag:: out ( O ) >

    copy ( R && r, O result ) ;
    		(2) (ranges TS)
    template < InputIterator I, Sentinel < I > S, WeaklyIncrementable O,

    class Proj = ranges:: identity ,
    IndirectUnaryPredicate < projected < I, Proj >> Pred >
    requires IndirectlyCopyable < I, O >
    ranges:: tagged_pair < tag:: in ( I ) , tag:: out ( O ) >

    copy_if ( I first, S last, O result, Pred pred, Proj proj = Proj { } ) ;
    		(3) (ranges TS)
    template < InputRange R, WeaklyIncrementable O,

    class Proj = ranges:: identity ,
    IndirectUnaryPredicate < projected < ranges:: iterator_t < R > , Proj >> Pred >
    requires IndirectlyCopyable < iterator_t < R > , O >
    ranges:: tagged_pair < tag:: in ( ranges:: safe_iterator_t < R > ) , tag:: out ( O ) >

    copy_if ( R && r, O result, Pred pred, Proj proj = Proj { } ) ;
    		(4) (ranges TS)

    Copie les éléments dans la plage source ( [ first , last ) ou r ) dans la plage de destination commençant à result , en partant du premier élément de la plage source et en procédant jusqu'au dernier.

    1) Copie tous les éléments dans l'intervalle [ first , last ) . Pour chaque entier non négatif n < (last - first) , exécute * ( result + n ) = * ( first + n ) . Le comportement est indéfini si result se trouve dans l'intervalle [ first , last ) . Dans ce cas, ranges::copy_backward peut être utilisé à la place.
    2) Identique à (1) , mais utilise r comme plage source, comme si par ranges:: copy ( ranges:: begin ( r ) , ranges:: end ( r ) , result ) ; sauf que result ne peut pas être copié.
    3) Ne copie que les éléments pour lesquels le prédicat pred renvoie true lorsqu'il est appliqué à la valeur de l'élément telle que projetée par la projection proj . L'ordre des éléments copiés est préservé. Le comportement est indéfini si les plages source et destination se chevauchent.
    4) Identique à (3) , mais utilise r comme plage source, comme si par ranges:: copy_if ( ranges:: begin ( r ) , ranges:: end ( r ) , result, pred, proj ) ; sauf que result , pred et proj ne peuvent pas être copiés.

    Nonobstant les déclarations dépeintes ci-dessus, le nombre réel et l'ordre des paramètres de template pour les déclarations d'algorithmes ne sont pas spécifiés. Ainsi, si des arguments de template explicites sont utilisés lors de l'appel d'un algorithme, le programme est probablement non portable.

    Sommaire

    Paramètres

    first, last - la plage d'éléments à copier
    r - la plage d'éléments à copier
    result - le début de la plage de destination
    pred - prédicat à appliquer aux éléments projetés
    proj - projection à appliquer aux éléments

    Valeur de retour

    Un objet tagged_pair contenant les deux membres suivants :

    • Le premier membre, avec l'étiquette tag::in , est l'itérateur de fin de la plage source (c'est-à-dire un itérateur de type I qui compare égal au sentinelle last ).
    • Le deuxième membre, avec l'étiquette tag::out , est l'itérateur de fin de la plage de résultat.

    Complexité

    1) Exactement ranges:: distance ( first, last ) affectations.
    2) Exactement ranges:: distance ( r ) affectations.
    3) Exactement ranges:: distance ( first, last ) applications de la projection et du prédicat correspondants.
    4) Exactement ranges:: distance ( r ) applications de la projection et du prédicat correspondants.

    Implémentations possibles

    Première version 
    template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O>
    requires IndirectlyCopyable<I, O>()
ranges::tagged_pair<tag::in(I), tag::out(O)>
    copy(I first, S last, O result)
{
    for (; first != last; ++first, (void)++result)
        *result = *first;
    return {first, result};
}
    Deuxième version 
    template<InputRange R, WeaklyIncrementable O>
    requires IndirectlyCopyable<ranges::iterator_t<R>, O>()
ranges::tagged_pair<tag::in(ranges::safe_iterator_t<R>), tag::out(O)>
    copy(R&& r, O result)
{
   return ranges::copy(ranges::begin(r), ranges::end(r), result);
}
    Troisième version 
    template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O,
         class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<I, Proj>> Pred>
    requires IndirectlyCopyable<I, O>()
ranges::tagged_pair<tag::in(I), tag::out(O)>
    copy_if(I first, S last, O result, Pred pred, Proj proj = Proj{})
{
    for (; first != last; ++first)
        if (ranges::invoke(pred, ranges::invoke(proj, *first)))
        {
            *result = *first;
            ++result;
        }
    return {first, result};
}
    Quatrième version 
    template<InputRange R, WeaklyIncrementable O,
         class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<ranges::iterator_t<R>, Proj>> Pred>
    requires IndirectlyCopyable<ranges::iterator_t<R>, O>()
ranges::tagged_pair<tag::in(ranges::safe_iterator_t<R>), tag::out(O)>
    copy_if(R&& r, O result, Pred pred, Proj proj = Proj{})
{
    return ranges::copy_if(ranges::begin(r), ranges::end(r), result, pred, proj);
}

    Exemple

    Le code suivant utilise copy pour copier le contenu d'un vecteur vers un autre et afficher le vecteur résultant :

    Exécuter ce code 
    #include <experimental/ranges/algorithm>
#include <experimental/ranges/iterator>
#include <iostream>
#include <numeric>
#include <vector>
int main()
{
    // see https://fr.cppreference.net/w/cpp/language/namespace_alias
    namespace ranges = std::experimental::ranges;
    std::vector<int> from_vector(10);
    std::iota(from_vector.begin(), from_vector.end(), 0);
    std::vector<int> to_vector;
    ranges::copy_if(from_vector.begin(), from_vector.end(),
                    ranges::back_inserter(to_vector),
                    [](const auto i)
                    {
                       return i % 3;
                    });
// or, alternatively,
//  std::vector<int> to_vector(from_vector.size());
//  std::copy(from_vector, to_vector.begin());
    std::cout << "to_vector contains: ";
    ranges::copy(to_vector, ranges::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
}

    Sortie : 

    to_vector contains: 1 2 4 5 7 8

    Voir aussi

    (C++11)
    		 copie une plage d'éléments vers un nouvel emplacement
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)(C++20)
    		copie une plage d'éléments dans l'ordre inverse
    (modèle de fonction)
    		crée une copie d'une plage inversée
    (modèle de fonction)
    		copie un nombre d'éléments vers un nouvel emplacement
    (modèle de fonction)
    		assigne une certaine valeur à une plage d'éléments
    (modèle de fonction)
    		copie une plage d'éléments en omettant ceux qui satisfont à des critères spécifiques
    (modèle de fonction)