C++ std::unique用法及代碼示例

std::unique用於刪除在range [first，last)中連續存在的任何元素的重複項。它對連續存在相同元素的範圍內存在的所有sub-groups執行此任務。

• 它不會刪除所有重複的元素，而是通過將序列中存在的下一個元素替換為與當前要替換的當前元素不重複的下一個元素來消除重複性。所有被替換的元素都處於未指定狀態。
• 此函數的另一個有趣的函數是，它在刪除元素後不會更改容器的大小，它僅返回一個指向容器新端的指針，並根據此指針來調整容器的大小或刪除容器的大小。垃圾元素。

可以按以下兩種方式使用它：

1. 使用==比較元素：
   用法:
   

   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.
   
   返回值：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; 
   }

   輸出：

   1 3 10 1 3 7 8
   

   在此，在此向量中，具有連續重複元素的所有sub-groups已減少為僅一個元素。請注意，以後是否也存在相同的元素並不重要，此函數僅處理連續出現的重複元素。

2. 通過使用預定義函數進行比較：
   用法:

   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.
   
   返回值：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; 
   }

   輸出：

   You arre vvvisiting GFG
   

   在這裏，我們以一種方式操縱二進製函數，即隻有將兩個G作為參數傳遞時，才將它們視為相同，並且如果連續出現任何其他字符，則它將保持不受影響，並且不會已移除(例如r代表arre，v代表訪問)。

哪裏可以使用str::unique？

1. 從容器中刪除所有重複的元素：你們中的許多人都必須搜索std::unique並認為它將刪除容器中的所有重複元素，現在您可能會有些失望，因為它知道它隻會刪除連續的重複元素。但是，盡管std::unique不能按照其定義進行操作，但是通過應用一些邏輯，我們可以實現這一目標。我們需要做的就是在應用std::unique之前對數組進行排序，以使所有相等的元素成為連續的，現在我們有了std::unique來刪除所有重複的連續元素。

   因此，std::unique也可以用於從容器中刪除所有重複的元素。

   // 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; 
   }

   輸出：

   1 2 3 7 8 10
   

   說明：首先，我們對數組進行排序，以使所有相等的重複元素變為連續的，然後對其應用std::unique，從而刪除重複項，並以此方式從容器中刪除所有重複的元素，無論是連續的還是重複的不。

2. 計算獨特元素：如果我們要計算總數，也可以使用它。容器中的獨特元素的集合。

   // 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; 
   }

   輸出：

   Total no. of unique elements = 5
   

   說明：我們知道std::unique在刪除重複的元素後將迭代器返回到應該是容器的新端的迭代器，因此隻計算總數就沒有了。在std::distance的幫助下從開始到新結束之間的元素數量，應為我們提供總數。容器中獨特元素的集合。