std::unique

template< class ForwardIt >
ForwardIt unique( ForwardIt first, ForwardIt last );

template< class ExecutionPolicy, class ForwardIt >
ForwardIt unique( ExecutionPolicy&& policy,
                  ForwardIt first, ForwardIt last );

template< class ForwardIt, class BinaryPred >
ForwardIt unique( ForwardIt first, ForwardIt last, BinaryPred p );

template< class ExecutionPolicy,
          class ForwardIt, class BinaryPred >
ForwardIt unique( ExecutionPolicy&& policy,
                  ForwardIt first, ForwardIt last, BinaryPred p );

Elimina todos excepto el primer elemento de cada grupo consecutivo de elementos equivalentes del rango [first, last) y devuelve un iterador al final (past-the-end) para el nuevo final del rango.

Explicación

La eliminación se realiza desplazando los elementos en el rango de tal manera que los elementos que no se deben eliminar aparezcan al principio del rango.

• El desplazamiento se realiza mediante copy assignment (until C++11) move assignment (since C++11) .
• La operación de eliminación es estable: el orden relativo de los elementos que no se eliminan permanece igual.
• La secuencia subyacente de [ first , last ) no se acorta mediante la operación de eliminación. Dado result como el iterador devuelto:

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

Parámetros

Valor de retorno

Un ForwardIt al nuevo final del rango.

Complejidad

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

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++ , libc++ , y MSVC STL .

template<class ForwardIt>
ForwardIt unique(ForwardIt first, ForwardIt last)
{
    if (first == last)
        return last;
    ForwardIt result = first;
    while (++first != last)
        if (!(*result == *first) && ++result != first)
            *result = std::move(*first);
    return ++result;
}

template<class ForwardIt, class BinaryPredicate>
ForwardIt unique(ForwardIt first, ForwardIt last, BinaryPredicate p)
{
    if (first == last)
        return last;
    ForwardIt result = first;
    while (++first != last)
        if (!p(*result, *first) && ++result != first)
            *result = std::move(*first);
    return ++result;
}

Notas

Una llamada a unique normalmente va seguida de una llamada a la función miembro erase del contenedor para eliminar realmente los elementos del contenedor.

Ejemplo

#include <algorithm>
#include <iostream>
#include <vector>
int main()
{
    // un vector que contiene varios elementos duplicados
    std::vector<int> v{1, 2, 1, 1, 3, 3, 3, 4, 5, 4};
    auto print = [&](int id)
    {
        std::cout << "@" << id << ": ";
        for (int i : v)
            std::cout << i << ' ';
        std::cout << '\n';
    };
    print(1);
    // eliminar duplicados consecutivos (adyacentes)
    auto last = std::unique(v.begin(), v.end());
    // v ahora contiene {1 2 1 3 4 5 4 x x x}, donde 'x' es indeterminado
    v.erase(last, v.end());
    print(2);
    // ordenar seguido de unique, para eliminar todos los duplicados
    std::sort(v.begin(), v.end()); // {1 1 2 3 4 4 5}
    print(3);
    last = std::unique(v.begin(), v.end());
    // v ahora contiene {1 2 3 4 5 x x}, donde 'x' es indeterminado
    v.erase(last, v.end());
    print(4);
}

@1: 1 2 1 1 3 3 3 4 5 4
@2: 1 2 1 3 4 5 4
@3: 1 1 2 3 4 4 5
@4: 1 2 3 4 5

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