std::copy_n - cppreference.com

</tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody>

1) Copia exactamente count valores del rango que comienza en first al rango que comienza en result. Formalmente, para cada entero 0 ≤ i < count, realiza *(result + i) = *(first + i). Formalmente, se permite la superposición de rangos, pero conlleva a un orden impredecible del resultado.

2) Lo mismo que (1), pero ejecutado de acuerdo a la política policy. Esta sobrecarga no participa en la resolución de sobrecarga a menos que std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> (hasta C++20) std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> (desde C++20) sea verdadera.

Parámetros

Valor de retorno

Un iterador en el rango destino que apunta después del último elemento copiado si count > 0; de lo contrario, result.

Complejidad

Cero asignaciones si count < 0; de lo contrario, count asignaciones.

Excepciones

La sobrecarga con un parámetro de plantilla llamado ExecutionPolicy (política de ejecución) reporta errores tales que:

• Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y la política de ejecución es una de las tres políticas estándar, se llama a std::terminate. Para cualquier otra política de ejecución, el comportamiento está definido por la implementación.
• Si el algoritmo falla al asignar memoria, se lanza std::bad_alloc.

Posible implementación

template<class InputIt, class Size, class OutputIt>
constexpr //< since C++20
OutputIt copy_n(InputIt first, Size count, OutputIt result)
{
    if (count > 0)
    {
        *result = *first;
        ++result;
        for (Size i = 1; i != count; ++i, ++result)
            *result = *++first;
    }

    return result;
}

Ejemplo

#include <algorithm>
#include <iostream>
#include <iterator>
#include <numeric>
#include <string>
#include <vector>

int main()
{
    std::string in {"1234567890"};
    std::string out;

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

    std::vector<int> v_in(128);
    std::iota(v_in.begin(), v_in.end(), 1);
    std::vector<int> v_out(v_in.size());

    std::copy_n(v_in.cbegin(), 100, v_out.begin());
    std::cout << std::accumulate(v_out.begin(), v_out.end(), 0) << '\n';
}

Véase también