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

Las entidades similares a funciones descritas en esta página son algorithm function objects (conocidas informalmente como niebloids ), es decir:

• No se pueden especificar listas de argumentos de plantilla explícitas al llamar a cualquiera de ellos.
• Ninguno de ellos es visible para la búsqueda dependiente de argumento .
• Cuando cualquiera de ellos es encontrado mediante la búsqueda no calificada normal como el nombre a la izquierda del operador de llamada a función, la búsqueda dependiente de argumento queda inhibida.

Parámetros

Valor de retorno

ranges :: copy_n_result { first + n, result + n } o más formalmente, un valor de tipo ranges::in_out_result que contiene un iterador input_iterator igual a ranges:: next ( first, n ) y un iterador weakly_incrementable igual a ranges:: next ( result, n ) .

Complejidad

Exactamente n asignaciones.

Notas

En la práctica, las implementaciones de std::ranges::copy_n pueden evitar asignaciones múltiples y utilizar funciones de copia masiva como std::memmove si el tipo de valor es TriviallyCopyable y los tipos de iterador satisfacen contiguous_iterator . Alternativamente, dicha aceleración de copia puede inyectarse durante una fase de optimización de un compilador.

Al copiar rangos superpuestos, std::ranges::copy_n es apropiado al copiar hacia la izquierda (el inicio del rango de destino está fuera del rango fuente) mientras que std::ranges::copy_backward es apropiado al copiar hacia la derecha (el final del rango de destino está fuera del rango fuente).

Implementación posible

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{};

Ejemplo

#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'

Véase también