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

Defined in header `<algorithm>`
Call signature
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)	(since 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)	(since C++20)
Helper types
template< class I, class O > using unique_copy_result = ranges::in_out_result<I, O>;	(3)	(since 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)	удаляет последовательные дубликаты элементов в диапазоне (niebloid)
ranges::copyranges::copy_if (C++20)(C++20)	копирует диапазон элементов в новое местоположение (niebloid)
ranges::adjacent_find (C++20)	находит первые два смежных элемента, которые равны (или удовлетворяют заданному предикату) (niebloid)
unique_copy	создает копию некоторого диапазона элементов, не содержащую последовательных дубликатов (шаблон функции)

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