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).

Два соседних элемента *(i - 1) и *i считаются эквивалентными, если std::invoke(comp, std::invoke(proj, *(i - 1)), std::invoke(proj, *i)) == true, где i — итератор в диапазоне [first + 1, last).

2) То же, что и (1), но использует r в качестве диапазона, как если бы ranges::begin(r) использовался в качестве first, а ranges::end(r) — в качестве last.

Функциональные объекты, описанные на этой странице, являются функциональными объектами алгоритмов (неофициально называемыми niebloids), то есть:

При вызове любого из них нельзя указывать явный список аргументов шаблона.
Ни один из них не виден для поиска, зависящего от аргументов.
Если любой из них найден посредством обычного неквалифицированного поиска как имя слева от оператора вызова функции, поиск, зависящий от аргументов, не выполняется.

Параметры

first, last	-	пара итератора и ограничителя, задающая исходный диапазон обрабатываемых элементов
r	-	исходный диапазон элементов
result	-	целевой диапазон элементов
comp	-	бинарный предикат для сравнения спроецированных элементов
proj	-	проекция, применяемая к элементам

Возвращаемое значение

{last, result + N}

Сложность

Ровно N - 1 применений соответствующего предиката comp и не более чем вдвое больше применений любой проекции proj.

Возможная реализация

См. также реализации в 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 {};

Пример

#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

См. также

ranges::unique (C++20)	удаляет соседние повторяющиеся элементы в диапазоне (функциональный объект алгоритма)
ranges::copyranges::copy_if (C++20)(C++20)	копирует диапазон элементов в новое место (функциональный объект алгоритма)
ranges::adjacent_find (C++20)	находит первые два соседних равных элемента (или удовлетворяющих заданному предикату) (функциональный объект алгоритма)
unique_copy	создаёт копию части диапазона элементов, не содержащую соседних повторов (шаблон функции)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/algorithm/ranges/unique_copy