std::copy_n

template< class InputIt, class Size, class OutputIt >
OutputIt copy_n( InputIt first, Size count, OutputIt result );

template< class ExecutionPolicy,
          class ForwardIt1, class Size, class ForwardIt2 >
ForwardIt2 copy_n( ExecutionPolicy&& policy,
                   ForwardIt1 first, Size count, ForwardIt2 result );

Paramètres

Valeur de retour

Itérateur dans la plage de destination, pointant après le dernier élément copié si count > 0 ou result sinon.

Complexité

Zéro affectation si count < 0; count affectations sinon.

Exceptions

La surcharge avec un paramètre template nommé ExecutionPolicy signale les erreurs comme suit :

• Si l'exécution d'une fonction invoquée dans le cadre de l'algorithme lance une exception et que ExecutionPolicy fait partie des politiques standard, std::terminate est appelée. Pour toute autre ExecutionPolicy, le comportement est défini par l'implémentation.
• Si l'algorithme échoue à allouer de la mémoire, std::bad_alloc est lancée.

Implémentation possible

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, (void)++result)
            *result = *++first;
    }
    
    return result;
}

Exemple

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

1234
5050

Voir aussi