std:: unique_copy

Copia los elementos del rango [ first , last ) a otro rango que comienza en d_first de tal manera que no haya elementos consecutivos iguales. 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 en d_first (desde C++20) , el programa está mal formado.

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

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

• T es tanto CopyConstructible como CopyAssignable .
• Se satisfacen todas las siguientes condiciones:

• OutputIt cumple con 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