std::remove, std::remove_if

template< class ForwardIt, class T = typename std::iterator_traits
                                         <ForwardIt>::value_type >
constexpr ForwardIt remove( ForwardIt first, ForwardIt last,
                            const T& value );

template< class ExecutionPolicy, class ForwardIt, class T >
ForwardIt remove( ExecutionPolicy&& policy,
                  ForwardIt first, ForwardIt last, const T& value );

template< class ExecutionPolicy, class ForwardIt,
          class T = typename std::iterator_traits
                        <ForwardIt>::value_type >
ForwardIt remove( ExecutionPolicy&& policy,
                  ForwardIt first, ForwardIt last, const T& value );

template< class ExecutionPolicy, class ForwardIt, class UnaryPred >
ForwardIt remove_if( ExecutionPolicy&& policy,
                     ForwardIt first, ForwardIt last, UnaryPred p );

Elimina todos los elementos que satisfacen un criterio especfico del rango [first, last) y devuelve un iterador pasado el final para el nuevo final del rango.

Explicacin

La eliminacin se realiza desplazando los elementos del rango de forma que los elementos que no se van a eliminar aparezcan al principio del rango.

• El desplazamiento se realiza mediante la asignacin de copia (hasta C++11)asignacin de movimiento (desde C++11).
• La operacin de eliminacin es estable: el orden relativo de los elementos que no se eliminarn permanece igual.
• La secuencia subyacente de [first, last) no se acorta mediante la operacin de eliminacin. Dado result como el iterador devuelto:

• Todos los iteradores en [result, last) siguen siendo desreferenciables.

Parmetros

Valor de retorno

Iterador pasado del final para el nuevo rango de valores (si ste no es end, entonces apunta a un valor no especificado, al igual que los iteradores a cualquier valor entre este iterador y end).

Complejidad

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

Excepciones

Las sobrecargas con un parmetro de plantilla llamado ExecutionPolicy (poltica de ejecucin) reportan errores tales que:

• Si la ejecucin de una funcin invocada como parte del algoritmo lanza una excepcin y la poltica de ejecucin es una de las tres polticas estndar, se llama a std::terminate. Para cualquier otra poltica de ejecucin, el comportamiento est definido por la implementacin.
• Si el algoritmo falla al asignar memoria, se lanza std::bad_alloc.

Posible implementacin

template<class ForwardIt, class T = typename std::iterator_traits<ForwardIt>::value_type>
ForwardIt remove(ForwardIt first, ForwardIt last, const T& value)
{
    first = std::find(first, last, value);
    if (first != last)
        for (ForwardIt i = first; ++i != last;)
            if (!(*i == value))
                *first++ = std::move(*i);
    return first;
}

template<class ForwardIt, class UnaryPred>
ForwardIt remove_if(ForwardIt first, ForwardIt last, UnaryPred p)
{
    first = std::find_if(first, last, p);
    if (first != last)
        for (ForwardIt i = first; ++i != last;)
            if (!p(*i))
                *first++ = std::move(*i);
    return first;
}

Notas

Una llamada a remove suele ir seguida de una llamada a la funcin miembro erase de un contenedor para eliminar elementos del contenedor. Estas dos invocaciones juntas constituyen lo que se denomina el modismo borrar-eliminar.

Las funciones miembro de nombre similar, de los contenedores list::remove, list::remove_if, forward_list::remove y forward_list::remove_if borran los elementos eliminados.

Estos algoritmos no se pueden utilizar con contenedores asociativos como std::set y std::map porque sus tipos de iterador no hacen desreferencia a los tipos AsignablePorMovimiento (las claves en estos contenedores no son modificables).

La biblioteca estndar tambin define una sobrecarga de std::remove en <cstdio>, que toma un const char* y se utiliza para eliminar archivos.

Debido a que std::remove toma value por referencia, puede tener un comportamiento no esperado si es una referencia a un elemento del rango [first, last).

Ejemplo

#include <algorithm>
#include <cassert>
#include <cctype>
#include <complex>
#include <iostream>
#include <string>
#include <string_view>
#include <vector>

int main()
{
    std::string str1 {"Texto con algunos   espacios"};
    
    auto noSpaceEnd = std::remove(str1.begin(), str1.end(), ' ');
    
    // Los espacios se eliminan de la cadena solo lgicamente.
    // Usamos una vista sobre cadena, la cadena original an no se ha reducido:
    std::cout << std::string_view(str1.begin(), noSpaceEnd) 
              << " tamao: " << str1.size() << '\n';
    
    str1.erase(noSpaceEnd, str1.end());
    
    // Los espacios se eliminan de la cadena fsicamente.
    std::cout << str1 << " tamao: " << str1.size() << '\n';
    
    std::string str2 = "Texto\n con\talgunos \t  espacios en blanco\n\n";
    str2.erase(std::remove_if(str2.begin(), 
                              str2.end(),
                              [](unsigned char x) { return std::isspace(x); }),
               str2.end());
    std::cout << str2 << '\n';

    std::vector<std::complex<double>> nums{{2, 2}, {1, 3}, {4, 8}};
    #ifdef __cpp_lib_algorithm_default_value_type
        nums.erase(std::remove(nums.begin(), nums.end(), {1, 3}), nums.end());
    #else
        nums.erase(std::remove(nums.begin(), nums.end(), std::complex<double>{1, 3}),
                   nums.end());
    #endif
    assert((nums == std::vector<std::complex<double>>{{2, 2}, {4, 8}}));
}

Textoconalgunosespacios tamao: 28
Textoconalgunosespacios tamao: 23
Textoconalgunosespaciosenblanco

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estndares de C++ publicados anteriormente.

Vase tambin