Привет, Хабр!

С выходом C++20 библиотека Range получила свое официальное место в языке, что ознаменовало некоторый важный шаг в развитии работы с контейнерами и итераторами. Это обновление ввело новый подход к манипуляциям с данными.

Итак, что же делает Range таким особенным? Традиционные итераторы требуют большого объема кода для выполнения простых операций вроде фильтрации или сортировки данных. С Range можно избавиться от этой сложности, с помощью интуитивно понятному и лаконичному способу работы с коллекциями данных. В этой статье мы и рассмотрим основные концепции библиотеки Range.

Основные концепции

Диапазоны — это основа библиотеки Range. Они представляют собой контейнеры или другие структуры данных, которые могут быть перебираемы. Основная идея состоит в том, чтобы описывать манипуляции с данными как последовательность преобразований.

Пример работы с диапазонами:

#include <iostream>
#include <ranges>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6};

    auto even_numbers = numbers | std::views::filter([](int n) { return n % 2 == 0; });

    for (int n : even_numbers) {
        std::cout << n << " "; // Вывод: 2 4 6
    }
}

Используем функцию std::views::filter, чтобы получить только четные числа из исходного диапазона. Диапазоны выглядят более выразительно по сравнению с традиционными итераторами.

Диапазоны не являются просто одним из способов итерирования контейнеров, а представляют собой полноценную абстракцию для работы с данными. Стандартные итераторы требуют постоянного поддержания некой точки доступа к данным, тогда как диапазоны работают на более высоком уровне — они "абстрагируются" от реальных данных и позволяют работать с последовательностями независимо от их реализации (будь то массивы, вектора, списки и т.д.).

Одно из сильных преимуществ диапазонов — это возможность линейно комбинировать множество преобразований без создания промежуточных контейнеров. Если бы мы применяли подобные операции без диапазонов, нам пришлось бы сохранять результаты каждого шага в новом контейнере. Диапазоны решают эту проблему благодаря ленивой обработке.

Views — это особый тип диапазонов, которые не копируют данные, а создают ленивые вычисления. Представления действуют как фильтры или трансформаторы данных: они "видят" исходные данные, но не изменяют их, а создают новую последовательность на основе исходной коллекции.

Особенность представлений — это ленивость. То есть, данные не обрабатываются сразу, а только тогда, когда они действительно необходимы (например, при итерации).

Пример использования представлений:

#include <iostream>
#include <ranges>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6};

    auto square_even_numbers = numbers
                               | std::views::filter([](int n) { return n % 2 == 0; })
                               | std::views::transform([](int n) { return n * n; });

    for (int n : square_even_numbers) {
        std::cout << n << " "; // Вывод: 4 16 36
    }
}

Здесь сначала фильтруются четные числа, а затем каждое из них возводится в квадрат с помощью std::views::transform. Поскольку представления ленивы, оба преобразования применяются только тогда, когда начинается итерация по результату.

Адаптеры — это функции, которые преобразуют диапазоны. Адаптеры применяются к диапазонам с помощью оператора | .

Наиболее часто используемые адаптеры:

• std::views::filter — фильтрует элементы на основе условия.

• std::views::transform — применяет функцию к каждому элементу диапазона.

• std::views::take — берёт первые N элементов диапазона.

• std::views::drop — пропускает первые N элементов диапазона.

Пример с адаптерами:

#include <iostream>
#include <ranges>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6};

    auto result = numbers 
                  | std::views::filter([](int n) { return n % 2 == 0; })
                  | std::views::take(2)
                  | std::views::transform([](int n) { return n * 2; });

    for (int n : result) {
        std::cout << n << " "; // Вывод: 4 8
    }
}

Комбинируем несколько адаптеров: сначала фильтруем четные числа, затем берём только первые два элемента и, наконец, удваиваем их. Всё это осуществляется в ленивой манере, без копирования данных.

Можно комбинировать диапазоны, представления и адаптеры, тем самым создавая цепочки преобразований данных, минимизируя сложность кода. Все эти преобразования будут проходить лениво — данные не обрабатываются до тех пор, пока не начнётся фактическая итерация.

Например:

auto result = std::views::iota(1, 100) // создаём диапазон от 1 до 100
               | std::views::filter([](int n) { return n % 2 == 0; }) // фильтруем только чётные
               | std::views::transform([](int n) { return n * n; }) // возводим в квадрат
               | std::views::take(10); // берём первые 10 элементов

for (int n : result) {
    std::cout << n << " "; // Вывод: 4 16 36 64 100 144 196 256 324 400
}

Диапазоны с ленивыми вычислениями позволяют работать с большими наборами данных, не загружая память.

Range с контейнерами STL

std::vector — это наиболее распространённый контейнер в C++, и его можно использовать с библиотекой Range для выполнения фильтрации, сортировки и трансформаций данных.

Пример фильтрации четных чисел и возведение их в квадрат:

#include <iostream>
#include <ranges>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    auto even_squares = numbers
                        | std::views::filter([](int n) { return n % 2 == 0; })
                        | std::views::transform([](int n) { return n * n; });

    for (int n : even_squares) {
        std::cout << n << " "; // Вывод: 4 16 36 64 100
    }
}

std::views::filter фильтрует четные числа, а std::views::transform возводит их в квадрат. Оба этих процесса происходят лениво, и данные не преобразуются, пока мы не начнём итерировать по результату.

std::list отличается от std::vector тем, что предоставляет двусвязный список, который поддерживает вставки и удаления в произвольных местах без необходимости смещения всех последующих элементов.

Пример извлечения и возведение в квадрат элементов списка с условием:

#include <iostream>
#include <ranges>
#include <list>

int main() {
    std::list<int> numbers = {10, 15, 20, 25, 30};

    auto transformed = numbers
                       | std::views::filter([](int n) { return n % 5 == 0; })
                       | std::views::transform([](int n) { return n * n; });

    for (int n : transformed) {
        std::cout << n << " "; // Вывод: 25 100 225 400 900
    }
}

Диапазоны могут работать с std::list, лениво преобразовывая и фильтруя его содержимое.

std::forward_list — это односвязный список, который поддерживает только последовательный доступ, и работа с ним через итераторы может быть несколько ограниченной. Однако благодаря библиотеке Range можно немного упростить этот процесс.

Например, пропустим первые два элемента и возьмем следующие три:

#include <iostream>
#include <ranges>
#include <forward_list>

int main() {
    std::forward_list<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8};

    auto result = numbers
                  | std::views::drop(2) // пропускаем первые два элемента
                  | std::views::take(3); // берем следующие три

    for (int n : result) {
        std::cout << n << " "; // Вывод: 3 4 5
    }
}

Даже с таким простым контейнером, как std::forward_list, Range позволяет управлять данными, используя такие адаптеры, как std::views::drop и std::views::take.

Пользовательские диапазоны и адаптера

Создание пользовательских диапазонов основывается на концепции итераторов и диапазонов в C++. Для этого достаточно реализовать необходимые методы begin() и end().

Пример простого пользовательского диапазона, который генерирует последовательность чисел:

#include <iostream>
#include <ranges>

class CustomRange {
public:
    CustomRange(int start, int end) : current(start), end_value(end) {}

    auto begin() const { return current; }
    auto end() const { return end_value; }

private:
    int current;
    int end_value;
};

int main() {
    CustomRange range(1, 10);

    for (int n : range) {
        std::cout << n << " "; // Вывод: 1 2 3 4 5 6 7 8 9
    }
}

Создали простой диапазон, который можно использовать в цикле for.

А вот уже создание пользовательского адаптера требует реализации функции, которая возвращает новый диапазон или изменённый вид существующего диапазона.

Пример создания пользовательского адаптера:

#include <iostream>
#include <ranges>
#include <vector>

struct custom_transform {
    int multiplier;
    custom_transform(int m) : multiplier(m) {}

    auto operator()(int n) const {
        return n * multiplier;
    }
};

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    auto transformed = numbers
                       | std::views::transform(custom_transform(3)); // Умножаем все элементы на 3

    for (int n : transformed) {
        std::cout << n << " "; // Вывод: 3 6 9 12 15
    }
}

Создаем кастомный адаптер, который умножает каждый элемент на заданное число.

Подробнее с Range можно ознакомиться здесь.

А на бесплатном вебинаре специализации C++ Developer коллеги из OTUS расскажут из каких этапов состоит компиляция программы на С++, покажут результаты выполнения каждого этапа, и проговорят возможные проблемы и их решения. Регистрация доступна по ссылке.