std::ranges::unique_copy, std::ranges::unique_copy_result

在头文件中定义 `<algorithm>`
调用签名
template< std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O, class Proj = std::identity, std::indirect_equivalence_relation<std::projected<I, Proj>> C = ranges::equal_to > requires std::indirectly_copyable<I, O> && (std::forward_iterator<I> \|\| (std::input_iterator<O> && std::same_as<std::iter_value_t<I>, std::iter_value_t<O>>) \|\| std::indirectly_copyable_storable<I, O>) constexpr unique_copy_result<I, O> unique_copy( I first, S last, O result, C comp = {}, Proj proj = {} );	(1)	(自 C++20 起)
template< ranges::input_range R, std::weakly_incrementable O, class Proj = std::identity, std::indirect_equivalence_relation<std::projected<ranges::iterator_t<R>, Proj>> C = ranges::equal_to > requires std::indirectly_copyable<ranges::iterator_t<R>, O> && (std::forward_iterator<ranges::iterator_t<R>> \|\| (std::input_iterator<O> && std::same_as<ranges::range_value_t<R>, std::iter_value_t<O>>) \|\| std::indirectly_copyable_storable<ranges::iterator_t<R>, O>) constexpr unique_copy_result<ranges::borrowed_iterator_t<R>, O> unique_copy( R&& r, O result, C comp = {}, Proj proj = {} );	(2)	(自 C++20 起)
辅助类型
template< class I, class O > using unique_copy_result = ranges::in_out_result<I, O>;	(3)	(自 C++20 起)

1) 将源范围 [first, last) 中的元素复制到以 result 开始的目标范围内，这样就不会有连续的相等元素。只复制每个相等元素组的第一个元素。

范围 [first, last) 和 [result, result + N) 不能重叠。 N = ranges::distance(first, last).

如果 std::invoke(comp, std::invoke(proj, *(i - 1)), std::invoke(proj, *i)) == true，则认为两个连续的元素 *(i - 1) 和 *i 等效，其中 i 是范围 [first + 1, last) 中的一个迭代器。

2) 与 (1) 相同，但使用 r 作为范围，就好像使用 ranges::begin(r) 作为 first，以及 ranges::end(r) 作为 last。

此页面上描述的函数式实体是 niebloid，也就是说

在调用任何这些实体时，不能指定显式模板参数列表。
它们都不对与参数相关的查找可见。
当通过普通非限定查找找到任何这些实体作为函数调用运算符左侧的名称时，与参数相关的查找被禁止。

在实践中，它们可能作为函数对象实现，或者使用特殊的编译器扩展。

[edit] 参数

first, last	-	元素的源范围
r	-	元素的源范围
result	-	元素的目标范围
comp	-	用于比较投影元素的二元谓词
proj	-	要应用于元素的投影

[edit] 返回值

{last, result + N}

[edit] 复杂度

正好 N - 1 次对应谓词 comp 的应用，以及不超过两倍的任何投影 proj 的应用。

[edit] 可能的实现

另请参阅 libstdc++ 和 MSVC STL 中的实现（以及第三方库：cmcstl2，NanoRange，以及 range-v3）。

struct unique_copy_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O,
             class Proj = std::identity,
             std::indirect_equivalence_relation<std::projected<I,
                 Proj>> C = ranges::equal_to>
    requires std::indirectly_copyable<I, O> && (std::forward_iterator<I> ||
                 (std::input_iterator<O> && std::same_as<std::iter_value_t<I>,
                     std::iter_value_t<O>>) || std::indirectly_copyable_storable<I, O>)
    constexpr ranges::unique_copy_result<I, O>
        operator()(I first, S last, O result, C comp = {}, Proj proj = {}) const
    {
        if (!(first == last))
        {
            std::iter_value_t<I> value = *first;
            *result = value;
            ++result;
            while (!(++first == last))
            {
                auto&& value2 = *first;
                if (!std::invoke(comp, std::invoke(proj, value2),
                        std::invoke(proj, value)))
                {
                    value = std::forward<decltype(value2)>(value2);
                    *result = value;
                    ++result;
                }
            }
        }
 
        return {std::move(first), std::move(result)};
    }
 
    template<ranges::input_range R, std::weakly_incrementable O, class Proj = std::identity,
             std::indirect_equivalence_relation<std::projected<ranges::iterator_t<R>,
                 Proj>> C = ranges::equal_to>
    requires std::indirectly_copyable<ranges::iterator_t<R>, O> &&
                 (std::forward_iterator<ranges::iterator_t<R>> ||
                 (std::input_iterator<O> && std::same_as<ranges::range_value_t<R>,
                     std::iter_value_t<O>>) ||
                 std::indirectly_copyable_storable<ranges::iterator_t<R>, O>)
    constexpr ranges::unique_copy_result<ranges::borrowed_iterator_t<R>, O>
        operator()(R&& r, O result, C comp = {}, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(result),
                       std::move(comp), std::move(proj));
    }
};
 
inline constexpr unique_copy_fn unique_copy {};

[edit] 示例

运行这段代码

#include <algorithm>
#include <cmath>
#include <iostream>
#include <iterator>
#include <list>
#include <string>
#include <type_traits>
 
void print(const auto& rem, const auto& v)
{
    using V = std::remove_cvref_t<decltype(v)>;
    constexpr bool sep{std::is_same_v<typename V::value_type, int>};
    std::cout << rem << std::showpos;
    for (const auto& e : v)
        std::cout << e << (sep ? " " : "");
    std::cout << '\n';
}
 
int main()
{
    std::string s1{"The      string    with many       spaces!"};
    print("s1: ", s1);
 
    std::string s2;
    std::ranges::unique_copy(
        s1.begin(), s1.end(), std::back_inserter(s2),
        [](char c1, char c2) { return c1 == ' ' && c2 == ' '; }
    );
    print("s2: ", s2);
 
    const auto v1 = {-1, +1, +2, -2, -3, +3, -3};
    print("v1: ", v1);
    std::list<int> v2;
    std::ranges::unique_copy(
        v1, std::back_inserter(v2),
        {}, // default comparator std::ranges::equal_to
        [](int x) { return std::abs(x); } // projection
    );
    print("v2: ", v2);
}

输出

s1: The      string    with many       spaces!
s2: The string with many spaces!
v1: -1 +1 +2 -2 -3 +3 -3 
v2: -1 +2 -3

[edit] 另请参阅

ranges::unique (C++20)	从一个范围内移除连续的重复元素 (niebloid)[edit]
ranges::copyranges::copy_if (C++20)(C++20)	将一个范围内的元素复制到一个新位置 (niebloid)[edit]
ranges::adjacent_find (C++20)	查找第一个满足给定谓词（或相等）的两个相邻项 (niebloid)[edit]
unique_copy	创建一个不包含连续重复元素的某些范围元素的副本 (函数模板) [edit]

编译器支持
独立和托管
语言
标准库
标准库头文件
命名要求
特性测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用实用程序库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
执行支持库 (C++26)
技术规范
符号索引
外部库

cppreference.com

命名空间

变体

视图

操作