std::ranges:: copy, std::ranges:: copy_if, std::ranges:: copy_result, std::ranges:: copy_if_result

From cppreference.net

Défini dans l'en-tête `<algorithm>`
Signature d'appel
template < std:: input_iterator I, std:: sentinel_for < I > S, std:: weakly_incrementable O > requires std:: indirectly_copyable < I, O > constexpr copy_result < I, O > copy ( I first, S last, O result ) ;	(1)	(depuis C++20)
template < ranges:: input_range R, std:: weakly_incrementable O > requires std:: indirectly_copyable < ranges:: iterator_t < R > , O > constexpr copy_result < ranges:: borrowed_iterator_t < R > , O > copy ( R && r, O result ) ;	(2)	(depuis C++20)
template < std:: input_iterator I, std:: sentinel_for < I > S, std:: weakly_incrementable O, class Proj = std:: identity , std:: indirect_unary_predicate < std :: projected < I, Proj >> Pred > requires std:: indirectly_copyable < I, O > constexpr copy_if_result < I, O > copy_if ( I first, S last, O result, Pred pred, Proj proj = { } ) ;	(3)	(depuis C++20)
template < ranges:: input_range R, std:: weakly_incrementable 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 copy_if_result < ranges:: borrowed_iterator_t < R > , O > copy_if ( R && r, O result, Pred pred, Proj proj = { } ) ;	(4)	(depuis C++20)
Types auxiliaires
template < class I, class O > using copy_result = ranges:: in_out_result < I, O > ;	(5)	(depuis C++20)
template < class I, class O > using copy_if_result = ranges:: in_out_result < I, O > ;	(6)	(depuis C++20)

Copie les éléments dans la plage, définie par [ first , last ) , vers une autre plage commençant à result .

1) Copie tous les éléments dans l'intervalle

first

last

en commençant par first et en poursuivant jusqu'à last - 1 . 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.

3) Ne copie que les éléments pour lesquels le prédicat pred retourne true . L'ordre relatif des éléments copiés est préservé. Le comportement est indéfini si les plages source et destination se chevauchent.

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 algorithme (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 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 ranges::in_out_result contenant un itérateur d'entrée égal à last et un itérateur de sortie au-delà du dernier élément copié.

Complexité

1,2) Exactement last - first affectations.

3,4) Exactement last - first applications du prédicat et de la projection, entre 0 et last - first assignations (assignation pour chaque élément pour lequel le prédicat retourne true , dépendant du prédicat et des données d'entrée).

Notes

En pratique, les implémentations de ranges::copy évitent les assignations multiples et utilisent des fonctions de copie en bloc telles que std::memmove si le type de valeur est TriviallyCopyable et que les types d'itérateurs satisfont contiguous_iterator .

Lors de la copie de plages qui se chevauchent, ranges::copy est approprié lors d'une copie vers la gauche (le début de la plage de destination est en dehors de la plage source) tandis que ranges::copy_backward est approprié lors d'une copie vers la droite (la fin de la plage de destination est en dehors de la plage source).

Implémentation possible

copier (1)(2)

struct copy_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O>
    requires std::indirectly_copyable<I, O>
    constexpr ranges::copy_result<I, O> operator()(I first, S last, O result) const
    {
        for (; first != last; ++first, (void)++result)
            *result = *first;
        return {std::move(first), std::move(result)};
    }
    template<ranges::input_range R, std::weakly_incrementable O>
    requires std::indirectly_copyable<ranges::iterator_t<R>, O>
    constexpr ranges::copy_result<ranges::borrowed_iterator_t<R>, O>
        operator()(R&& r, O result) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(result));
    }
};
inline constexpr copy_fn copy;

copy_if (3)(4)

struct copy_if_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O,
             class Proj = std::identity,
             std::indirect_unary_predicate<std::projected<I, Proj>> Pred>
    requires std::indirectly_copyable<I, O>
    constexpr ranges::copy_if_result<I, O>
        operator()(I first, S last, O result, Pred pred, Proj proj = {}) const
    {
        for (; first != last; ++first)
            if (std::invoke(pred, std::invoke(proj, *first)))
            {
                *result = *first;
                ++result;
            }
        return {std::move(first), std::move(result)};
    }
    template<ranges::input_range R, std::weakly_incrementable 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 ranges::copy_if_result<ranges::borrowed_iterator_t<R>, O>
        operator()(R&& r, O result, Pred pred, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(result),
                       std::ref(pred), std::ref(proj));
    }
};
inline constexpr copy_if_fn copy_if;

Exemple

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

Exécuter ce code

#include <algorithm>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
int main()
{
    std::vector<int> source(10);
    std::iota(source.begin(), source.end(), 0);
    std::vector<int> destination;
    std::ranges::copy(source.begin(), source.end(), std::back_inserter(destination));
// ou, alternativement,
//  std::vector<int> destination(source.size());
//  std::ranges::copy(source.begin(), source.end(), destination.begin());
// les deux méthodes sont équivalentes à
//  std::vector<int> destination = source;
    std::cout << "Destination contient : ";
    std::ranges::copy(destination, std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
    std::cout << "Les nombres impairs dans destination sont : ";
    std::ranges::copy_if(destination, std::ostream_iterator<int>(std::cout, " "),
                         [](int x) { return (x % 2) == 1; });
    std::cout << '\n';
}

Sortie :

Destination contient : 0 1 2 3 4 5 6 7 8 9
Les nombres impairs dans destination sont : 1 3 5 7 9

Voir aussi

ranges::copy_backward (C++20)	copie une plage d'éléments dans l'ordre inverse (objet fonction algorithme)
ranges::reverse_copy (C++20)	crée une copie d'une plage inversée (objet fonction algorithme)
ranges::copy_n (C++20)	copie un nombre d'éléments vers un nouvel emplacement (objet fonction algorithme)
ranges::fill (C++20)	assigne une valeur à une plage d'éléments (objet fonction algorithme)
ranges::remove_copy ranges::remove_copy_if (C++20) (C++20)	copie une plage d'éléments en omettant ceux qui satisfont des critères spécifiques (objet fonction algorithme)
copy copy_if (C++11)	copie une plage d'éléments vers un nouvel emplacement (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