本系列文章的目錄在這裡：(目錄). 通過目錄裡可以對STL總體有個大概瞭解

前言

本文介紹了STL中的unique演算法的使用，結合一個具體例子講解如何使用它刪除自定義型別結合裡面的重複元素(不僅僅是連續的)。

原型

<algorithm>中的unique函式， 它能刪除連續序列的副本(Remove consecutive duplicates in range).

原型如下:

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

template <class ForwardIterator, class BinaryPredicate>
  ForwardIterator unique ( ForwardIterator first, ForwardIterator last,
                           BinaryPredicate pred );
 

“刪除連續序列”這樣的描述容易造成誤解，知道下面幾點有助於更好理解這個操作：

1. 其實unique僅僅是按照一個規則來修改[first, last)之間的元素，並不會刪除任何東西，它不會改變容器的size。這個規則就是連續一樣的元素會被後面的元素覆蓋。

2. 它通過一個返回迭代器result，並保證在[first, result)之間的元素是不存在連續重複的元素。可以把[result, last)之間的元素移除掉，這才算刪除了連續重複的元素。

3. 預設判斷兩個元素相等是使用==操作符，第二個版本也可自己指定二元函式（函式，函式子，lambda).

看看與它等價的程式碼就知道了：

template <class ForwardIterator>
  ForwardIterator unique (ForwardIterator first, ForwardIterator last)
{
  if (first==last) return last;

  ForwardIterator result = first;
  while (++first != last)
  {
    if (!(*result == *first))  // or: if (!pred(*result,*first)) for version (2)
      *(++result)=*first;
  }
  return ++result;
}

// 程式碼摘自 http://www.cplusplus.com/reference/algorithm/unique/
 

簡單示例

模擬這個原型程式碼的執行過程：

如果原始序列是： 1,2,2,3,2,1,1
那麼unique之後：1,2,3,2,1,1,1， 容器元素被修改了，但是個數沒變，需要手動再把結尾的1,1刪掉，這個位置由unique的返回值來確定，下面的程式碼演示了這個過程：

#include <iostream>
#include <iterator>     // ostream_iterator
#include <algorithm>    // unique，distance
#include <vector>

int main() {
    using namespace std;
    vector<int> vi{1,2,2,3,2,1,1};
    // 去重
    auto result = unique(vi.begin(), vi.end());
    // 刪除
    vi.resize(distance(vi.begin(), result));
    copy(vi.begin(), vi.end(), ostream_iterator<int>(cout, ","));
    return 0;
}

輸出：

1,2,3,2,1,

實習中對unique運用

下面的例子是在完成實習任務中的應用，在做圖片輪廓提取的時候，得到一些點的座標，我在點與點之間畫線，把輪廓描繪出來，在使用OpenCV提取輪廓點之後，有些資料點重複，它們並不是連續重複的，比如：

(1, 2), (3, 4), (1, 2), (3, 4), (3, 4), (1,2)
我要把所有重複的點刪掉，不能僅僅刪除連續重複的，如果用unique結果會是:
(1, 2), (3, 4), (1, 2), (3, 4), (1, 2)

不能把所有重複的刪掉。所以不能直接使用unique，要先把點排序，這樣重複的點都變成連續的了，接下來就可以用unique一次搞定了。這幾步都能用stl輕鬆實現，下面是示例程式碼：

#include <iostream>
#include <iterator>     // ostream_iterator
#include <algorithm>    // sort, copy, unique
#include <vector>

class Point {
public:
    Point(int x, int y) {
        x_ = x;
        y_ = y;
    }

    // 用於copy()庫函式.
    Point(const Point& other) {
        x_ = other.x_;
        y_ = other.y_;
    }

    // 用於sort庫函式.
    bool operator<(const Point & other) {
        return ((x_ < other.x_) && (y_ < other.y_));
    }

    // 用於erase庫函式.
    bool operator==(const Point & other) const {
        return ((x_ == other.x_) && (y_ == other.y_));
    }

    int x() const { return x_; }
    int y() const { return y_; }
private:
    int x_, y_;
};

// 過載<<操作符，為了使用ostream_iterator<Point>
std::ostream& operator<<(std::ostream& os, const Point & p) {
    os << "(" << p.x() << ", " << p.y() << ")";
    return os;
}

int main() {

    using namespace std;

    // c++11風格容器初始化，使用初始化列表(initializer_list)
    vector<Point> vp { Point(1, 2), Point(3, 4), Point(1, 2), Point(3, 4), Point(3, 4), Point(1, 2) };

    // 列印容器內的Point到標準輸出流cout. 以逗號分隔.
    cout << "origin..." << endl;
    copy(vp.begin(), vp.end(), ostream_iterator<Point>(cout, ","));
    putchar(10);
    putchar(10);

    // 容器排序. 為了後面的unique操作，因為unique是刪除連續相同元素的副本.
    sort(vp.begin(), vp.end());
    cout << "after sorting..." << endl;

    // 列印排序後的容器內容.
    copy(vp.begin(), vp.end(), ostream_iterator<Point>(cout, ","));
    putchar(10);
    putchar(10);

    // 刪除重複元素.
    auto it = unique(vp.begin(), vp.end()); // it 型別為 vector<Point>::iterator
    vp.erase(it, vp.end());

    // 列印處理後的內容.
    cout << "after unique..." << endl;
    copy(vp.begin(), vp.end(), ostream_iterator<Point>(cout, ","));
    putchar(10);

    return 0;
}

執行結果：

origin...
(1, 2),(3, 4),(1, 2),(3, 4),(3, 4),(1, 2),

after sorting...
(1, 2),(1, 2),(1, 2),(3, 4),(3, 4),(3, 4),

after unique...
(1, 2),(3, 4),

作者水平有限，對相關知識的理解和總結難免有錯誤，還望給予指正，非常感謝！


歡迎訪問github部落格，與本站同步更新