Namespaces
Variants

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

From 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.

Table des matières

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://en.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)
copie une plage d'éléments dans l'ordre inverse
(modèle de fonction)
crée une copie d'une plage qui est inversée
(modèle de fonction)
copie un nombre d'éléments vers un nouvel emplacement
(modèle de fonction)
assigne une valeur spécifique à 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)