std::ranges::unique

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 = {} );

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 = {} );

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

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

Параметры

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

Возвращает { ret, last } , где ret является итератором, указывающим за конец нового диапазона.

Сложность

Для непустых диапазонов ровно ranges:: distance ( first, last ) - 1 применений соответствующего предиката comp и не более чем вдвое больше применений любой проекции proj .

Примечания

Удаление осуществляется путем сдвига (посредством перемещающего присваивания) элементов в диапазоне таким образом, что элементы, которые не должны быть удалены, появляются в начале диапазона. Относительный порядок оставшихся элементов сохраняется, а физический размер контейнера не изменяется. Итераторы в [ ret , last ) (если есть) остаются разыменуемыми, но сами элементы имеют неопределенные значения (в соответствии с MoveAssignable пост-условием).

Вызов ranges::unique иногда сопровождается вызовом функции-члена erase контейнера, которая удаляет неопределённые значения и уменьшает физический размер контейнера, чтобы соответствовать его новому логическому размеру. Вместе эти два вызова реализуют идиому Erase–remove .

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

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()
{
    // вектор, содержащий несколько дублирующихся элементов
    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);
    // сортировка с последующим 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)

Смотрите также