std:: copy, std:: copy_if

Copie les éléments dans la plage, définie par [ first , last ) , vers une autre plage commençant à d_first (plage de destination de copie).

Paramètres

Valeur de retour

Itérateur de sortie vers l'élément dans la plage de destination, un après le dernier élément copié.

Complexité

Étant donné \(\scriptsize N\) N comme std:: distance ( first, last ) :

Pour les surcharges avec une ExecutionPolicy , il peut y avoir un coût de performance si le type de valeur de ForwardIt1 n'est pas MoveConstructible .

Exceptions

Les surcharges avec un paramètre de modèle nommé ExecutionPolicy signalent les erreurs comme suit :

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

Implémentation possible

template<class InputIt, class OutputIt>
OutputIt copy(InputIt first, InputIt last,
              OutputIt d_first)
{
    for (; first != last; (void)++first, (void)++d_first)
        *d_first = *first;
    return d_first;
}

template<class InputIt, class OutputIt, class UnaryPred>
OutputIt copy_if(InputIt first, InputIt last,
                 OutputIt d_first, UnaryPred pred)
{
    for (; first != last; ++first)
        if (pred(*first))
        {
            *d_first = *first;
            ++d_first;
        }
    return d_first;
}

Notes

En pratique, les implémentations de std::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 LegacyContiguousIterator .

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

Exemple

#include <algorithm>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
int main()
{
    std::vector<int> from_vector(10);
    std::iota(from_vector.begin(), from_vector.end(), 0);    
    std::vector<int> to_vector;
    std::copy(from_vector.begin(), from_vector.end(), std::back_inserter(to_vector));
// or, alternatively,
//  std::vector<int> to_vector(from_vector.size());
//  std::copy(from_vector.begin(), from_vector.end(), to_vector.begin());
// either way is equivalent to
//  std::vector<int> to_vector = from_vector;
    std::cout << "to_vector contains: ";
    std::copy(to_vector.begin(), to_vector.end(),
              std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
    std::cout << "odd numbers in to_vector are: ";
    std::copy_if(to_vector.begin(), to_vector.end(),
                 std::ostream_iterator<int>(std::cout, " "),
                 [](int x) { return x % 2 != 0; });
    std::cout << '\n';
    std::cout << "to_vector contains these multiples of 3: ";
    to_vector.clear();
    std::copy_if(from_vector.begin(), from_vector.end(),
                 std::back_inserter(to_vector),
                 [](int x) { return x % 3 == 0; });
    for (const int x : to_vector)
        std::cout << x << ' ';
    std::cout << '\n';
}

to_vector contains: 0 1 2 3 4 5 6 7 8 9
odd numbers in to_vector are: 1 3 5 7 9
to_vector contains these multiples of 3: 0 3 6 9

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi