std::copy, std::copy_if

Copia los elementos en el rango definido por [firt, last), a otro rango que comienza en d_first.

[editar] Parámetros

[editar] Valor de retorno

El iterador de salida al elemento en el rango destino, uno más allá del último elemento copiado.

[editar] Complejidad

Para las sobrecargas con una política de ejecución, ExecutionPolicy, podría haber un costo de rendimiento si el tipo del valor de ForwardIt1 no es MoveConstructible.

[editar] Excepciones

Las sobrecargas con un parámetro de plantilla llamado ExecutionPolicy (política de ejecución) reportan 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.

[editar] Notas

En la práctica, las implementaciones de std::copy evitan asignaciones múltiples y utilizan funciones de copia en masa tales como std::memmove si el tipo del valor es TriviallyCopyable y los tipos iterador satisfacen a ContiguousIterator.

Al copiar rasgos que se superponen, std::copy es apropiado al copiar a la izquierda (el inicio del rango destino se encuentra fuera del rango fuente), mientras que std::copy_backward es apropiado al copiar a la derecha (el final del rango destino se encuentra fuera del rango fuente).

[editar] Posible implementación

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 UnaryPredicate>
OutputIt copy_if(InputIt first, InputIt last,
                 OutputIt d_first, UnaryPredicate pred)
{
    for (; first != last; ++first)
    {
        if (pred(*first))
        {
            *d_first = *first;
            ++d_first;
        }
    }
 
    return d_first;
}

[editar] Ejemplo

#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));
// o alternativamente,
//  std::vector<int> to_vector(from_vector.size());
//  std::copy(from_vector.begin(), from_vector.end(), to_vector.begin());
// de cualquier manera es equivalente a
//  std::vector<int> to_vector = from_vector;
 
    std::cout << "to_vector contiene: ";
 
    std::copy(to_vector.begin(), to_vector.end(),
              std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
 
	std::cout << "Los números impares en to_vector son: ";
 
    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 contiene estos múltiplos de 3:\n";
 
    to_vector.clear();
    std::copy_if(from_vector.begin(), from_vector.end(),
                 std::back_inserter(to_vector),
                 [](int x) { return x % 3 == 0; });
 
    for (int x : to_vector)
        std::cout << x << ' ';
    std::cout << '\n';
}

to_vector contiene: 0 1 2 3 4 5 6 7 8 9
Los números impares en to_vector son: 1 3 5 7 9
to_vector contiene estos múltiplos de 3
0 3 6 9

[editar] Véase también