std::ranges::copy_n, std::ranges::copy_n_result

template< std::input_iterator I, std::weakly_incrementable O >
requires std::indirectly_copyable<I, O>
constexpr copy_n_result<I, O>
    copy_n( I first, std::iter_difference_t<I> n, O result );

template< class I, class O >
using copy_n_result = ranges::in_out_result<I, O>;

Les entités de type fonction décrites sur cette page sont des objets fonctions d'algorithmes (informellement connus sous le nom de niebloids), c'est-à-dire :

• Les listes explicites d'arguments de modèle ne peuvent pas être spécifiées lors de l'appel de l'une d'entre elles.
• Aucun d'entre eux n'est visible par recherche dépendante des arguments.
• Lorsque l'un d'entre eux est trouvé par recherche non qualifiée normale comme le nom à gauche de l'opérateur d'appel de fonction, recherche dépendante des arguments est inhibée.

Paramètres

Valeur de retour

ranges::copy_n_result{first + n, result + n} ou plus formellement, une valeur de type ranges::in_out_result qui contient un input_iterator itérateur égal à ranges::next(first, n) et un weakly_incrementable itérateur égal à ranges::next(result, n).

Complexité

Exactement n affectations.

Notes

En pratique, les implémentations de std::ranges::copy_n peuvent éviter les affectations multiples et utiliser des fonctions de copie en masse telles que std::memmove si le type de valeur est TriviallyCopyable et que les types d'itérateurs satisfont contiguous_iterator. Alternativement, une telle accélération de copie peut être injectée lors d'une phase d'optimisation d'un compilateur.

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

Implémentation possible

struct copy_n_fn
{
    template<std::input_iterator I, std::weakly_incrementable O>
    requires std::indirectly_copyable<I, O>
    constexpr ranges::copy_n_result<I, O>
        operator()(I first, std::iter_difference_t<I> n, O result) const
    {
        for (; n-- > 0; (void)++first, (void)++result)
            *result = *first;

        return {std::move(first), std::move(result)};
    }
};

inline constexpr copy_n_fn copy_n{};

Exemple

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <string>
#include <string_view>

int main()
{
    const std::string_view in{"ABCDEFGH"};
    std::string out;

    std::ranges::copy_n(in.begin(), 4, std::back_inserter(out));
    std::cout << std::quoted(out) << '\n';

    out = "abcdefgh";
    const auto res{std::ranges::copy_n(in.begin(), 5, out.begin())};
    const auto i{std::distance(std::begin(in), res.in)};
    const auto j{std::distance(std::begin(out), res.out)};
    std::cout << "in[" << i << "] = '" << in[i] << "'\n"
              << "out[" << j << "] = '" << out[j] << "'\n";
}

"ABCD"
in[5] = 'F'
out[5] = 'f'

Voir aussi