Espacios de nombres
Variantes
Acciones

std::remove_copy, std::remove_copy_if

De cppreference.com
< cpp‎ | algorithm
 
 
Biblioteca de algoritmos
Políticas de ejecución (C++17)
Operaciones de secuencia no modificantes
(C++11)(C++11)(C++11)
(C++17)
Operaciones de secuencia modificantes
Operaciones en almacenamiento no inicializado
Operaciones de partición
Operaciones de ordenación
(C++11)
Operaciones de búsqueda binaria
Operaciones de conjuntos (en rangos ordenados)
Operaciones de pila
(C++11)
Operaciones mínimo/máximo
(C++11)
(C++17)
Permutaciones
Operaciones numéricas
Bibliotecas C
 
Definido en el archivo de encabezado <algorithm>
(1)
template< class InputIt, class OutputIt, class T >

OutputIt remove_copy( InputIt first, InputIt last,

                      OutputIt d_first, const T& value );
(hasta C++20)
template< class InputIt, class OutputIt, class T >

constexpr OutputIt remove_copy( InputIt first, InputIt last,

                                OutputIt d_first, const T& value );
(desde C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class T >

ForwardIt2 remove_copy( ExecutionPolicy&& policy,
                        ForwardIt1 first, ForwardIt1 last,

                        ForwardIt2 d_first, const T& value );
(2) (desde C++17)
(3)
template< class InputIt, class OutputIt, class UnaryPredicate >

OutputIt remove_copy_if( InputIt first, InputIt last,

                         OutputIt d_first, UnaryPredicate p );
(hasta C++20)
template< class InputIt, class OutputIt, class UnaryPredicate >

constexpr OutputIt remove_copy_if( InputIt first, InputIt last,

                                   OutputIt d_first, UnaryPredicate p );
(desde C++20)
template< class ExecutionPolicy, class ForwardIt1,

          class ForwardIt2, class UnaryPredicate >
ForwardIt2 remove_copy_if( ExecutionPolicy&& policy,
                           ForwardIt1 first, ForwardIt1 last,

                           ForwardIt2 d_first, UnaryPredicate p );
(4) (desde C++17)

Copia elementos del rango [firstlast) a otro rango que comienza en d_first, omitiendo los elementos que cumplen con un criterios específico.

1) Ignora todos los elementos que son iguales a value.
3) Ignora todos los elementos para los cuales el predicado p devuelve true.
2,4) Igual que (1,3), pero se ejecuta de acuerdo a la política de ejecución policy. Estas sobrecargas no participan en la resolución de sobrecarga a menos que std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> (hasta C++20) std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> (desde C++20) sea verdadera.

Si los rangos de origen y destino se superponen, el comportamiento no está definido.

Contenido

[editar] Parámetros

first, last - El rango de elementos a copiar.
d_first - El comienzo del rango de destino.
value - El valor de los elementos a no copiar.
policy - La política de ejecución a usar. Véase política de ejecución para más detalles.
Requisitos de tipo
-
InputIt debe satisfacer los requisitos de InputIterator.
-
OutputIt debe satisfacer los requisitos de OutputIterator.
-
ForwardIt1, ForwardIt2 debe satisfacer los requisitos de ForwardIterator.
-
UnaryPredicate debe satisfacer los requisitos de Predicate.

La expresión *d_first = *first debe ser válida.

(hasta C++20)

*first debe ser escribible para d_first.

(desde C++20)

[editar] Valor de retorno

Un iterador al elemento más allá del último elemento copiado.

[editar] Complejidad

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

1,2) exactamente N comparaciones con value usando operator==.
3,4) exactamente N aplicaciones del predicado p.

Paa las sobrecargas con una política de ejecución puede haber un costo de rendimiento si el tipo valor (value_type) 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] Posible implementación

remove_copy
template<class InputIt, class OutputIt, class T>
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;
}
remove_copy_if
template<class InputIt, class OutputIt, class UnaryPredicate>
OutputIt remove_copy_if(InputIt first, InputIt last, OutputIt d_first, UnaryPredicate p)
{
    for (; first != last; ++first)
        if (!p(*first))
            *d_first++ = *first;
    return d_first;
}

[editar] Ejemplo

El siguiente código genera una cadena al ir borrando los caracteres hash '#' sobre la marcha.

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <string>
 
int main()
{
    std::string str = "#Optimización #del #Valor #de #Retorno";
    std::cout << "before: " << std::quoted(str) << '\n';
 
    std::cout << "after:  \"";
    std::remove_copy(str.begin(), str.end(),
                     std::ostream_iterator<char>(std::cout), '#');
    std::cout << "\"\n";
}

Salida:

before: "#Optimización #del #Valor #de #Retorno"
after:  "Optimización del Valor de Retorno"

[editar] Informes de defectos

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

ID Aplicado a Comportamiento según lo publicado Comportamiento correcto
LWG 779 C++98 Se requería que T fuera EqualityComparable, pero
el tipo valor de ForwardIt no siempre es T.
Se requiere que en su lugar *d_first = *first
sea válido.

[editar] Véase también

Elimina elementos que satisfacen un criterio específico.
(plantilla de función) [editar]
Copia un rango de elementos a una nueva ubicación.
(plantilla de función) [editar]
Copia un rango dividiendo los elementos en dos grupos.
(plantilla de función) [editar]
Copia un rango de elementos, omitiendo aquellos que satisfacen un criterio específico
(niebloid) [editar]