std:: remove_copy, std:: remove_copy_if

Copia elementos del rango [ first , last ) , a otro rango que comienza en d_first , omitiendo los elementos que satisfacen criterios específicos.

Si * d_first = * first es inválido (hasta C++20) * first no es escribible en d_first (desde C++20) , el programa está mal formado.

Si los rangos de origen y destino se superponen, el comportamiento es indefinido.

Parámetros

Valor de retorno

Iterador al elemento después del último elemento copiado.

Complejidad

Dado \(\scriptsize N\) N como std:: distance ( first, last ) :

Para las sobrecargas con una ExecutionPolicy, puede haber un costo de rendimiento si ForwardIt1 's value_type no es MoveConstructible .

Excepciones

Las sobrecargas con un parámetro de plantilla llamado ExecutionPolicy reportan errores de la siguiente manera:

• Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y ExecutionPolicy es uno de los standard policies , std::terminate es llamado. Para cualquier otro ExecutionPolicy , el comportamiento está definido por la implementación.
• Si el algoritmo falla al asignar memoria, std::bad_alloc es lanzado.

Implementación posible

template<class InputIt, class OutputIt,
         class T = typename std::iterator_traits<InputIt>::value_type>
constexpr OutputIt remove_copy(InputIt first, InputIt last,
                               OutputIt d_first, const T& value)
{
    for (; first != last; ++first)
        if (!(*first == value))
            *d_first++ = *first;
    return d_first;
}

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

Notas

Ejemplo

#include <algorithm>
#include <complex>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
int main()
{
    // Eliminar los caracteres '#' sobre la marcha.
    std::string str = "#Return #Value #Optimization";
    std::cout << "antes: " << std::quoted(str) << '\n';
    std::cout << "después:  \"";
    std::remove_copy(str.begin(), str.end(),
                     std::ostream_iterator<char>(std::cout), '#');
    std::cout << "\"\n";
    // Eliminar valor {1, 3} sobre la marcha.
    std::vector<std::complex<double>> nums{{2, 2}, {1, 3}, {4, 8}, {1, 3}};
    std::remove_copy(nums.begin(), nums.end(),
                     std::ostream_iterator<std::complex<double>>(std::cout),
    #ifdef __cpp_lib_algorithm_default_value_type
                     {1, 3}); // T se deduce
    #else
                     std::complex<double>{1, 3});
    #endif
}

antes: "#Return #Value #Optimization"
después:  "Return Value Optimization"
(2,2)(4,8)

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también