std::ranges::copy, std::ranges::copy_if, std::ranges::copy_result, std::ranges::copy_if_result
De fr.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 d'aide |
||
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 de la plage définie par [first, last) vers une autre plage commençant à result.
1) Copie tous les éléments de la plage
[first, last) en partant de first et en allant vers last - 1. Le comportement est indéfini si result se trouve dans la plage [first, last). Dans ce cas, il est préférable d'utiliser ranges::copy_backward.3) Copie uniquement les éléments pour lesquels le prédicat
pred renvoie true. L'ordre relatif des éléments copiés est conservé. 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 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 de 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 leur appel.
- Aucune d'entre elles n'est visible par la recherche dépendante des arguments.
- Lorsque l'une d'elles est trouvée par une recherche non qualifiée normale comme le nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.
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 situé après le 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 affectations (une affectation pour chaque élément pour lequel le prédicat renvoie true, dépendant du prédicat et des données d'entrée).Notes
En pratique, les implémentations de ranges::copy évitent les affectations 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 de la 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 de la copie vers la droite (la fin de la plage de destination est en dehors de la plage source).
Implémentation possible
| copy (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 à la fois pour copier le contenu d'un std::vector dans 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));
// or, alternatively,
// std::vector<int> destination(source.size());
// std::ranges::copy(source.begin(), source.end(), destination.begin());
// either way is equivalent to
// std::vector<int> destination = source;
std::cout << "Destination contains: ";
std::ranges::copy(destination, std::ostream_iterator<int>(std::cout, " "));
std::cout << '\n';
std::cout << "Odd numbers in destination are: ";
std::ranges::copy_if(destination, std::ostream_iterator<int>(std::cout, " "),
[](int x) { return (x % 2) == 1; });
std::cout << '\n';
}
Sortie :
Destination contains: 0 1 2 3 4 5 6 7 8 9
Odd numbers in destination are: 1 3 5 7 9
Voir aussi
(C++20) |
copie une plage d'éléments en ordre inverse (objet de fonction d'algorithme) |
(C++20) |
crée une copie inversée d'une plage (objet de fonction d'algorithme) |
(C++20) |
copie un nombre d'éléments vers un nouvel emplacement (objet de fonction d'algorithme) |
(C++20) |
assigne une certaine valeur à une plage d'éléments (objet de fonction d'algorithme) |
(C++20)(C++20) |
copie une plage d'éléments en omettant ceux qui satisfont des critères spécifiques (objet de fonction d'algorithme) |
(C++11) |
copie une plage d'éléments vers un nouvel emplacement (modèle de fonction) |