// <algorithm> 
// 等价比较(1)    
template <class ForwardIterator>
    ForwardIterator unique (
        ForwardIterator first,
        ForwardIterator last);
// 自定义谓词比较(2)    
template <class ForwardIterator,
    class BinaryPredicate>
    ForwardIterator unique (
       ForwardIterator first,
       ​ForwardIterator last,
       BinaryPredicate pred);

删除指定范围中的所有连续重复元素,仅仅留下每组等值元素中的第一个元素。

该函数等价于:

template<class _FwdIt,
    class _Pr> inline
    _FwdIt _Unique(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
    {    // remove each satisfying _Pred with previous
    if (_First != _Last)
        for (_FwdIt _Firstb; (_Firstb = _First), ++_First != _Last; )
            if (_Pred(*_Firstb, *_First))
                {    // copy down
                for (; ++_First != _Last; )
                    if (!_Pred(*_Firstb, *_First))
                        *++_Firstb = _Move(*_First);
                return (++_Firstb);
                }
    return (_Last);
    }
  • firstlast

    分别指向序列中初始及末尾位置的正向迭代器(Forward Iterators)。这个范围即 [first,last) ,包括 first 到 last 间的所有元素,包括 first 指向的元素,但不包括 last 指向的元素。

    pred

    二元谓词(Binary)函数,以两个元素为参数,然后返回一个可转换成 bool 类型的值。

    其返回值表明指定两个元素是否满足当前函数所检测的匹配条件。

    该函数不能修改其参数。

    可以是函数指针(Function pointer)类型或函数对象(Function object)类型。

  • 指向最后一个未被删除元素之后位置的迭代器。

    在 first 及该返回值所表示的范围中所有相邻元素都不等价(Equivalent)

  • 例 1

    #include <iostream>
    #include <algorithm>
    #include <iterator>
    #include <vector>
    
    #define CLASSFOO_VECTOR(type, name, ...) \
    static const type name##_a[] = __VA_ARGS__; \
    std::vector<type> name(name##_a, name##_a + sizeof(name##_a) / sizeof(*name##_a))
    
    namespace ClassFoo{
        bool IfEqual(int m, int n) {
            return (m == n);
        }
        void Unique_1() {
            CLASSFOO_VECTOR(int, BigVector1, { 8, 23, 5, 5, 7, 7, 29, 0, 7, 7, 7, 1, 1 });
            CLASSFOO_VECTOR(int, BigVector2, { 8, 23, 5, 5, 7, 7, 29, 0, 7, 7, 7, 1, 1 });
            // 等价比较
            std::vector<int>::iterator it = std::unique(
                std::begin(BigVector1),
                std::end(BigVector1));
            BigVector1.erase(it, BigVector1.end());
            // 输出去重后的结果
            std::copy(
                BigVector1.begin(),
                BigVector1.end(),
                std::ostream_iterator<int>(std::cout, " "));
            std::cout << std::endl;
    
            // 自定谓词比较
            it = std::unique(
                std::begin(BigVector2),
                std::end(BigVector2),
                IfEqual);
            BigVector2.erase(it, BigVector2.end());
            // 输出去重后的结果
            std::copy(
                BigVector2.begin(),
                BigVector2.end(),
                std::ostream_iterator<int>(std::cout, " "));
            std::cout << std::endl;
        }
    }
    int main()
    {
        ClassFoo::Unique_1();
        return 0;
    }

    8 23 5 7 29 0 7 1 
    8 23 5 7 29 0 7 1 

    例 2

    C++11

    #include <iostream>
    #include <algorithm>
    #include <iterator>
    #include <vector>
    
    namespace ClassFoo{
        bool IfEqual(int m, int n) {
            return (m == n);
        }
        void Unique_2() {
            std::vector<int> BigVector1 = { 8, 23, 5, 5, 7, 7, 29, 0, 7, 7, 7, 1, 1 };
            std::vector<int> BigVector2 = { 8, 23, 5, 5, 7, 7, 29, 0, 7, 7, 7, 1, 1 };
            // 等价比较
            auto it = std::unique(
                std::begin(BigVector1),
                std::end(BigVector1));
            BigVector1.erase(it, BigVector1.end());
            // 输出去重后的结果
            std::copy(
                BigVector1.begin(),
                BigVector1.end(),
                std::ostream_iterator<int>(std::cout, " "));
            std::cout << std::endl;
    
            // 自定谓词比较
            it = std::unique(
                std::begin(BigVector2),
                std::end(BigVector2),
                IfEqual);
            BigVector2.erase(it, BigVector2.end());
            // 输出去重后的结果
            std::copy(
                BigVector2.begin(),
                BigVector2.end(),
                std::ostream_iterator<int>(std::cout, " "));
            std::cout << std::endl;
        }
    }
    int main()
    {
        ClassFoo::Unique_2();
        return 0;
    }

    8 23 5 7 29 0 7 1 
    8 23 5 7 29 0 7 1 

  • 复杂度

    O(n)n 为 last first.

    数据争用相关

    访问在范围 [first,last) 中的所有元素,各个元素都有可能被修改。

    异常安全性相关

    如果谓词 pred、赋值操作或操作某个迭代器抛异常,该函数才会抛异常。

    注意 无效参数将导致未定义行为(Undefined behavior)