std::único en C++

std::unique se usa para eliminar duplicados de cualquier elemento presente consecutivamente en un rango [primero, último]. Realiza esta tarea para todos los subgrupos presentes en el rango que tengan el mismo elemento presente consecutivamente.

• No elimina todos los elementos duplicados, pero elimina la duplicación simplemente reemplazando esos elementos por el siguiente elemento presente en la secuencia que no está duplicado en el elemento actual que se reemplaza. Todos los elementos que se reemplazan quedan en un estado no especificado.
• Otra característica interesante de esta función es que no cambia el tamaño del contenedor después de eliminar los elementos, solo devuelve un puntero que apunta al nuevo extremo del contenedor y, en función de eso, tenemos que cambiar el tamaño del contenedor o eliminar el elementos de basura

Se puede utilizar de dos formas como se muestra a continuación:

1. Comparando elementos usando ==:
   Sintaxis:

   template 
   ForwardIterator unique (ForwardIterator first, ForwardIterator last);
   
   first: Forward iterator to the first element in the container.
   last: forward iterator to the last element in the container.
   
   Return Value: It returns an iterator to the element that follows 
   the last element not removed. The range between first and this iterator includes 
   all the elements in the sequence that were not
   duplicates and hence not removed.
   

   // C++ program to demonstrate the use of std::unique #include <iostream> #include <vector> #include <algorithm> using namespace std; int main() {     vector<int> v = { 1, 1, 3, 3, 3, 10, 1, 3, 3, 7, 7, 8 }, i;        vector<int>::iterator ip;        // Using std::unique     ip = std::unique(v.begin(), v.begin() + 12);     // Now v becomes {1 3 10 1 3 7 8 * * * * *}     // * means undefined        // Resizing the vector so as to remove the undefined terms     v.resize(std::distance(v.begin(), ip));        // Displaying the vector after applying std::unique     for (ip = v.begin(); ip != v.end(); ++ip) {         cout << *ip << " ";     }        return 0; }

   Producción:

   1 3 10 1 3 7 8
   

   Aquí, en este vector, todos los subgrupos que tienen elementos duplicados consecutivos se han reducido a un solo elemento. Tenga en cuenta que no importa si el mismo elemento está presente más adelante, esta función solo maneja los elementos duplicados presentes consecutivamente.

2. Comparando usando una función predefinida:
   Sintaxis:

   template 
    ForwardIterator unique (ForwardIterator first, ForwardIterator last,
                            BinaryPredicate Pred);
   
   Here, first and last are the same as previous case.
   
   Pred: Binary function that accepts two elements 
   in the range as argument, and returns a value convertible to bool. 
   The value returned indicates whether both arguments are considered equivalent
   (if true, they are equivalent and one of them is removed).
   The function shall not modify any of its arguments.
   This can either be a function pointer or a function object.
   
   Return Value: It returns an iterator to the element that 
   follows the last element not removed.
   The range between first and this iterator includes 
   all the elements in the sequence that were not
   duplicates and hence not removed.

   // C++ program to demonstrate the use of std::unique #include <iostream> #include <algorithm> #include <string> using namespace std;    // Defining the BinaryFunction bool Pred(char a, char b) {     // Checking if both the arguments are same and equal     // to 'G' then only they are considered same     // and duplicates are removed     if (a == b && a == 'G') {         return 1;     } else {         return 0;     } } int main() {     // Declaring a string     string s = "You arre vvvisiting GGGGFGGGG";        // Using std::unique to remove the consecutive     // G in the word     auto ip = std::unique(s.begin(), s.end(), Pred);        // Displaying the corrected string     cout << string(s.begin(), ip);     return 0; }

   Producción:

   You arre vvvisiting GFG
   

   Aquí, hemos manipulado la función binaria de tal manera que solo si se pasan dos G como argumentos, solo se considerarán como iguales, y si cualquier otro carácter está presente consecutivamente, no se verá afectado y no será eliminado (como r en arre, v en visita).

¿Dónde se puede usar str::unique?

1. Elimine todos los elementos duplicados de un contenedor: muchos de ustedes deben haber buscado std::unique con la idea de que eliminará todos los elementos duplicados del contenedor, y ahora puede sentirse un poco decepcionado al saber que elimina solo el elementos duplicados consecutivos. Pero, aunque std::unique no puede hacerlo según su definición, pero aplicando un poco de lógica, podemos hacer que eso suceda. Lo que debemos hacer es ordenar la array antes de aplicar std::unique, de modo que todos los elementos iguales se vuelvan consecutivos, y ahora tenemos std::unique para eliminar todos los elementos consecutivos duplicados.

   Por lo tanto, std::unique también se puede usar para eliminar todos los elementos duplicados de un contenedor.

   // C++ program to demonstrate the use of std::unique #include <iostream> #include <vector> #include <algorithm> using namespace std; int main() {     vector<int> v = { 1, 2, 3, 3, 3, 10, 1, 2, 3, 7, 7, 8 };        vector<int>::iterator ip;        // Sorting the array     std::sort(v.begin(), v.end());     // Now v becomes 1 1 2 2 3 3 3 3 7 7 8 10        // Using std::unique     ip = std::unique(v.begin(), v.begin() + 12);     // Now v becomes {1 2 3 7 8 10 * * * * * *}     // * means undefined        // Resizing the vector so as to remove the undefined terms     v.resize(std::distance(v.begin(), ip));        // Displaying the vector after applying std::unique     for (ip = v.begin(); ip != v.end(); ++ip) {         cout << *ip << " ";     }        return 0; }

   Producción:

   1 2 3 7 8 10
   

   Explicación: En primer lugar, ordenamos la array de modo que todos los elementos duplicados iguales se vuelvan consecutivos y ahora le aplicamos std::unique de modo que se elimine la duplicación, y de esta manera eliminamos todos los elementos duplicados de un contenedor, ya sea consecutivo o no.

2. Contar elementos únicos: también se puede usar si queremos contar el número total. de elementos únicos en un contenedor.

   // C++ program to demonstrate the use of std::unique #include <iostream> #include <iterator> #include <vector> #include <algorithm> using namespace std; int main() {     vector<int> v = { 1, 1, 3, 3, 3, 10, 1, 3, 3, 7, 7, 8 };        vector<int>::iterator ip;        int count;     sort(v.begin(), v.end());        // Using std::unique and std::distance to count     // unique elements in a container     count = std::distance(v.begin(),                           std::unique(v.begin(), v.begin() + 12));        // Displaying the value of count     cout << "Total no. of unique elements = " << count;        return 0; }

   Producción:

   Total no. of unique elements = 5
   

   Explicación: como sabemos, std::unique devuelve un iterador a lo que debería ser el nuevo final del contenedor después de eliminar los elementos duplicados, por lo que solo contamos el número total. de elementos desde el principio hasta este nuevo final con la ayuda de std::distance, debería darnos el número total. de elementos únicos en el envase.

Este artículo es una contribución de Mrigendra Singh . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.