std::ranges::unique

從 cppreference.com
< cpp‎ | algorithm‎ | ranges
 
 
算法庫
受約束算法及範圍上的算法 (C++20)
包含算法例如 ranges::copy, ranges::sort, ...
執行策略 (C++17)
排序和相關操作
劃分操作
排序操作
二分搜索操作(在已劃分範圍上)
集合操作(在有序範圍上)
歸併操作(在有序範圍上)
堆操作
最小/最大操作
(C++11)
(C++17)
字典序比較操作
排列操作
C 庫

數值運算
(C++11)                       
在未初始化內存上的操作
 
受約束算法
本菜單中的所有名字均屬於命名空間 std::ranges
不修改序列的操作
修改序列的操作
劃分操作
排序操作
二分搜索操作(在有序範圍上)
       
       
集合操作(在有序範圍上)
堆操作
最小/最大操作
       
       
排列操作
摺疊操作
數值操作
(C++23)            
未初始化存儲上的操作
返回類型
 
在標頭 <algorithm> 定義
調用簽名
template< std::permutable I, std::sentinel_for<I> S, class Proj = std::identity,

          std::indirect_equivalence_relation<std::projected<I, Proj>>
              C = ranges::equal_to >
constexpr ranges::subrange<I>

    unique( I first, S last, C comp = {}, Proj proj = {} );
(1) (C++20 起)
template< ranges::forward_range R, class Proj = std::identity,

          std::indirect_equivalence_relation<std::projected<ranges::iterator_t<R>, Proj>>
              C = ranges::equal_to >
requires std::permutable<ranges::iterator_t<R>>
constexpr ranges::borrowed_subrange_t<R>

    unique( R&& r, C comp = {}, Proj proj = {} );
(2) (C++20 起)
1) 消除範圍 [firstlast) 的每個連續的等價元素組中首個以外的全部元素,並返回子範圍 [retlast),其中 ret 是新範圍的尾後迭代器。
std::invoke(comp, std::invoke(proj, *(i - 1)), std::invoke(proj, *i)) == true 則認為二個連續元素 *(i - 1)*i 等價,其中 i 是範圍 [first + 1last) 中的迭代器。
2)(1),但以 r 為範圍,如同以 ranges::begin(r)first 並以 ranges::end(r)last

此頁面上描述的函數式實體是算法函數對象(非正式地稱為 niebloid),即:

目錄

[編輯] 參數

first, last - 處理的元素範圍的迭代器-哨位對
r - 要處理的元素範圍
comp - 比較投影后元素的二元謂詞
proj - 應用到元素的投影

[編輯] 返回值

返回 {ret, last},其中 ret 是新範圍末尾的尾後迭代器。

[編輯] 複雜度

對於非空範圍,準確應用相應的謂詞 comp ranges::distance(first, last) - 1 次,並且應用投影 proj 的次數不多於其二倍。

[編輯] 註解

由遷移(通過移動賦值的手段)範圍中的元素進行移除,使得未被移除的元素出現在範圍起始。保持元素的相對順序並且不改變容器的物理大小。[retlast) 中的迭代器(若存在)仍然可解引用,但元素自身擁有未指定值(如可移動賦值 (MoveAssignable) 後條件所要求)。

ranges::unique 的調用有時後隨容器的 erase 成員函數,這擦除未指定值並減少容器的物理大小以匹配其新的邏輯大小。此二調用一併實現擦除-移除手法

[編輯] 可能的實現

struct unique_fn
{
    template<std::permutable I, std::sentinel_for<I> S, class Proj = std::identity,
             std::indirect_equivalence_relation<std::projected<I, Proj>>
                 C = ranges::equal_to>
    constexpr ranges::subrange<I>
        operator()(I first, S last, C comp = {}, Proj proj = {}) const
    {
        first = ranges::adjacent_find(first, last, comp, proj);
        if (first == last)
            return {first, first};
        auto i {first};
        ++first;
        while (++first != last)
            if (!std::invoke(comp, std::invoke(proj, *i), std::invoke(proj, *first)))
                *++i = ranges::iter_move(first);
        return {++i, first};
    }
 
    template<ranges::forward_range R, class Proj = std::identity,
             std::indirect_equivalence_relation<std::projected<ranges::iterator_t<R>, Proj>>
                 C = ranges::equal_to>
    requires std::permutable<ranges::iterator_t<R>>
    constexpr ranges::borrowed_subrange_t<R>
        operator()(R&& r, C comp = {}, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r),
                       std::move(comp), std::move(proj));
    }
};
 
inline constexpr unique_fn unique {};

[編輯] 示例

#include <algorithm>
#include <cmath>
#include <complex>
#include <iostream>
#include <vector>
 
struct id {
    int i;
    explicit id(int i) : i {i} {}
};
 
void print(id i, const auto& v)
{
    std::cout << i.i << ") ";
    std::ranges::for_each(v, [](auto const& e) { std::cout << e << ' '; });
    std::cout << '\n';
}
 
int main()
{
    // 含数个重复元素的 vector
    std::vector<int> v{1, 2, 1, 1, 3, 3, 3, 4, 5, 4};
 
    print(id {1}, v);
 
    // 移除连续(相接)的副本
    const auto ret = std::ranges::unique(v);
    // v 现在保有 {1 2 1 3 4 5 4 x x x},其中 'x' 不确定
    v.erase(ret.begin(), ret.end());
    print(id {2}, v);
 
    // sort 后随 unique,移除所有副本
    std::ranges::sort(v); // {1 1 2 3 4 4 5}
    print(id {3}, v);
 
    const auto [first, last] = std::ranges::unique(v.begin(), v.end());
    // v 现在保有 {1 2 3 4 5 x x},其中 'x' 不确定
    v.erase(first, last);
    print(id {4}, v);
 
    // 以定制比较与投影 unique
    std::vector<std::complex<int>> vc{ {1, 1}, {-1, 2}, {-2, 3}, {2, 4}, {-3, 5} };
    print(id {5}, vc);
 
    const auto ret2 = std::ranges::unique(vc,
        [](int x, int y) { return std::abs(x) == std::abs(y); }, // comp
        [](std::complex<int> z) { return z.real(); }             // proj
    );
    vc.erase(ret2.begin(), ret2.end());
    print(id {6}, vc);
}

輸出:

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
5) (1,1) (-1,2) (-2,3) (2,4) (-3,5)
6) (1,1) (-2,3) (-3,5)

[編輯] 參閱

創建某範圍的不含連續重複元素的副本
(算法函數對象) [編輯]
查找首對相同(或滿足給定謂詞)的相鄰元素
(算法函數對象) [編輯]
移除滿足特定條件的元素
(算法函數對象) [編輯]
移除範圍中連續重複元素
(函數模板) [編輯]
刪除連續的重複元素
(std::list<T,Allocator> 的公開成員函數) [編輯]
刪除連續的重複元素
(std::forward_list<T,Allocator> 的公開成員函數) [編輯]