std::unique_copy

template< class InputIt, class OutputIt >
OutputIt unique_copy( InputIt first, InputIt last, OutputIt d_first );

template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >
ForwardIt2 unique_copy( ExecutionPolicy&& policy, ForwardIt1 first,
                        ForwardIt1 last, ForwardIt2 d_first );

template< class InputIt, class OutputIt, class BinaryPred >
OutputIt unique_copy( InputIt first, InputIt last,
                      OutputIt d_first, BinaryPred p );

template< class ExecutionPolicy, class ForwardIt1,
          class ForwardIt2, class BinaryPred >
ForwardIt2 unique_copy( ExecutionPolicy&& policy,
                        ForwardIt1 first, ForwardIt1 last,
                        ForwardIt2 d_first, BinaryPred p );

Copia los elementos del rango [first, last), a otro rango comenzando en d_first de tal manera que no haya elementos iguales consecutivos. Solo se copia el primer elemento de cada grupo de elementos iguales.

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

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

Dado T como el tipo de valor de InputIt, si la sobrecarga (1) o (3) no satisface todas las siguientes condiciones, el comportamiento no está definido:

• T es tanto CopyConstructible como CopyAssignable.
• Todas las siguientes condiciones se satisfacen:

• OutputIt cumple los requisitos de LegacyForwardIterator.
• El tipo de valor de OutputIt también es T.
• T es CopyAssignable.

Parámetros

Valor de retorno

Iterador de salida al elemento después del último elemento escrito.

Complejidad

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

Para las sobrecargas (2,4) , puede haber un costo de rendimiento si el tipo de valor de ForwardIt1 no es tanto CopyConstructible como CopyAssignable .

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

Consulte también las implementaciones en libstdc++ y libc++ .

Notas

Si InputIt satisface LegacyForwardIterator , esta función vuelve a leer la entrada para detectar duplicados.

De lo contrario, si OutputIt satisface LegacyForwardIterator , y el tipo de valor de InputIt es el mismo que el de OutputIt , esta función compara * d_first con * first .

De lo contrario, esta función compara * first con una copia local del elemento.

Ejemplo

#include <algorithm>
#include <iostream>
#include <iterator>
#include <string>
int main()
{
    std::string s1 {"A string with mmmany letters!"};
    std::cout << "Before: " << s1 << '\n';
    std::string s2;
    std::unique_copy(s1.begin(), s1.end(), std::back_inserter(s2),
                     [](char c1, char c2) { return c1 == 'm' && 'm' == c2; });
    std::cout << "After:  " << s2 << '\n';
}

Before: A string with mmmany letters!
After:  A string with many letters!

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