C++

Представления, ленивое вычисление и композиция

Освойте представления C++20 — легковесные ленивые адаптеры диапазонов, компонуемые через оператор pipe. Изучите filter, transform, take, drop, split, join, iota и создание мощных конвейеров данных без промежуточных выделений памяти.

Что такое представления?

Представление (view) — это легковесный диапазон, который:

1. Невладеющий — не владеет элементами, на которые ссылается
2. O(1) копирование и перемещение — представления дёшево передавать
3. Ленивое вычисление — элементы вычисляются по запросу во время итерации, а не заранее

Представления — строительные блоки конвейеров диапазонов. Вместо создания промежуточных контейнеров на каждом шаге представления компонуются в один проход по данным:

// Традиционно: создаёт 2 промежуточных вектора
auto evens = filter(data, is_even);     // выделение памяти
auto squared = transform(evens, sq);    // выделение памяти

// Представления: ноль промежуточных выделений
auto result = data | views::filter(is_even) | views::transform(sq);
// Ничего ещё не вычислено — result — это просто дескриптор представления
for (int x : result) { ... }  // вычисляется поэлементно

Представления находятся в std::views:: (псевдоним пространства имён для std::ranges::views::).

filter и transform — фундаментальные представления

views::filter оставляет элементы, соответствующие предикату. views::transform применяет функцию к каждому элементу. Вместе они заменяют большинство явных циклов.

filter_transform.cpp
#include <ranges>
#include <vector>
#include <string>
#include <iostream>

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

    // Filter even numbers, then square them
    auto even_squares = numbers
        | std::views::filter([](int x) { return x % 2 == 0; })
        | std::views::transform([](int x) { return x * x; });

    // Nothing has been computed yet — even_squares is a view
    for (int x : even_squares) {
        std::cout << x << ' ';  // 4 16 36 64 100
    }
    std::cout << '\n';

    // Views work with any range — including strings
    std::string text = "Hello, World!";
    auto uppercase = text
        | std::views::filter([](char c) { return std::isalpha(c); })
        | std::views::transform([](char c) { return std::toupper(c); });

    for (char c : uppercase) {
        std::cout << c;  // HELLOWORLD
    }
    std::cout << '\n';

    // Collect view results into a vector (C++23: std::ranges::to)
    std::vector<int> collected;
    for (int x : even_squares) {
        collected.push_back(x);
    }
    // C++23: auto collected = even_squares | std::ranges::to<std::vector>();
}

take, drop и представления для нарезки

views::take(n) возвращает первые n элементов. views::drop(n) пропускает первые n элементов. Вместе они обеспечивают эффективную нарезку без копирования.

take_drop.cpp
#include <ranges>
#include <vector>
#include <iostream>

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

    // take — first N elements
    for (int x : data | std::views::take(3)) {
        std::cout << x << ' ';  // 1 2 3
    }
    std::cout << '\n';

    // drop — skip first N elements
    for (int x : data | std::views::drop(7)) {
        std::cout << x << ' ';  // 8 9 10
    }
    std::cout << '\n';

    // Combine: elements 3-7 (0-indexed: drop 3, take 4)
    for (int x : data | std::views::drop(3) | std::views::take(4)) {
        std::cout << x << ' ';  // 4 5 6 7
    }
    std::cout << '\n';

    // take_while / drop_while — predicate-based
    std::vector<int> sorted_data = {1, 3, 5, 7, 2, 4, 6};

    auto ascending_prefix = sorted_data | std::views::take_while(
        [prev = 0](int x) mutable {
            bool ok = x > prev;
            prev = x;
            return ok;
        });
    for (int x : ascending_prefix) {
        std::cout << x << ' ';  // 1 3 5 7
    }
    std::cout << '\n';

    // Pagination example: page 2, page_size = 3
    int page = 2, page_size = 3;
    auto page_view = data
        | std::views::drop((page - 1) * page_size)
        | std::views::take(page_size);
    for (int x : page_view) {
        std::cout << x << ' ';  // 4 5 6
    }
    std::cout << '\n';
}

split, join и представления для обработки строк

views::split разделяет диапазон по разделителю. views::join уплощает вложенные диапазоны. Они мощны для обработки строк и данных.

split_join.cpp
#include <ranges>
#include <string>
#include <string_view>
#include <vector>
#include <iostream>

int main() {
    // split — divide a string by delimiter
    std::string csv = "Alice,30,Engineer,95000";

    for (auto field : csv | std::views::split(',')) {
        // Each 'field' is a subrange — convert to string_view
        std::string_view sv(field.begin(), field.end());
        std::cout << '[' << sv << "] ";
    }
    std::cout << '\n';  // [Alice] [30] [Engineer] [95000]

    // join — flatten nested ranges
    std::vector<std::vector<int>> matrix = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    for (int x : matrix | std::views::join) {
        std::cout << x << ' ';  // 1 2 3 4 5 6 7 8 9
    }
    std::cout << '\n';

    // Combine: split lines, then process each line
    std::string multiline = "hello world\nfoo bar\nbaz qux";
    int line_num = 1;
    for (auto line : multiline | std::views::split('\n')) {
        std::string_view line_sv(line.begin(), line.end());
        std::cout << line_num++ << ": " << line_sv << '\n';
    }

    // Enumerate (C++23)
    // for (auto [i, val] : data | std::views::enumerate) { ... }
}

views::iota — генерация диапазонов

views::iota генерирует последовательность возрастающих значений. Он может быть ограниченным (iota(0, 10) для 0..9) или неограниченным (iota(0) для 0, 1, 2, ...). В сочетании с take заменяет многие циклы со счётчиком.

views_iota.cpp
#include <ranges>
#include <iostream>
#include <vector>
#include <numeric>

int main() {
    // Bounded iota — replaces for(int i = 0; i < 10; ++i)
    for (int x : std::views::iota(0, 10)) {
        std::cout << x << ' ';  // 0 1 2 3 4 5 6 7 8 9
    }
    std::cout << '\n';

    // Unbounded iota + take — first 5 squares
    auto first_5_squares = std::views::iota(1)
        | std::views::transform([](int x) { return x * x; })
        | std::views::take(5);
    for (int x : first_5_squares) {
        std::cout << x << ' ';  // 1 4 9 16 25
    }
    std::cout << '\n';

    // Generate Fibonacci-like sequence with views
    // (iota as index generator)
    auto indices = std::views::iota(0, 20);
    auto even_indices = indices | std::views::filter([](int i) { return i % 2 == 0; });
    for (int i : even_indices | std::views::take(5)) {
        std::cout << i << ' ';  // 0 2 4 6 8
    }
    std::cout << '\n';

    // Use iota to create a vector of sequential values
    auto range_vec = std::views::iota(1, 11);  // 1 to 10
    int sum = 0;
    for (int x : range_vec) sum += x;
    std::cout << "Sum 1..10: " << sum << '\n';  // 55
}

Построение полных конвейеров данных

Истинная мощь представлений проявляется при композиции нескольких адаптеров в единый конвейер. Весь конвейер вычисляется лениво за один проход.

data_pipeline.cpp
#include <ranges>
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>

struct LogEntry {
    std::string level;   // "INFO", "WARN", "ERROR"
    std::string message;
    int timestamp;
};

int main() {
    std::vector<LogEntry> logs = {
        {"INFO",  "Server started",      1000},
        {"ERROR", "Connection refused",  1001},
        {"INFO",  "Request received",    1002},
        {"WARN",  "Slow query detected", 1003},
        {"ERROR", "Timeout expired",     1004},
        {"INFO",  "Request completed",   1005},
        {"ERROR", "Disk full",           1006},
        {"WARN",  "Memory usage high",   1007},
    };

    // Pipeline: get recent error messages, formatted
    auto recent_errors = logs
        | std::views::filter([](const LogEntry& e) {
              return e.level == "ERROR";
          })
        | std::views::drop(1)            // skip first error
        | std::views::transform([](const LogEntry& e) {
              return "[" + std::to_string(e.timestamp) + "] " + e.message;
          })
        | std::views::take(5);           // at most 5 results

    std::cout << "Recent errors (after first):\n";
    for (const auto& msg : recent_errors) {
        std::cout << "  " << msg << '\n';
    }
    // [1004] Timeout expired
    // [1006] Disk full

    // Reverse view — iterate backward without copying
    auto reversed = logs | std::views::reverse | std::views::take(3);
    std::cout << "\nLast 3 entries (reversed):\n";
    for (const auto& e : reversed) {
        std::cout << "  [" << e.level << "] " << e.message << '\n';
    }
}
Подводный камень

Представления являются невладеющими — они ссылаются на базовый диапазон. Если исходный диапазон уничтожен, представление становится висячим:

auto make_view() {
    std::vector<int> local = {1, 2, 3};
    return local | std::views::filter([](int x) { return x > 1; });
    // ОШИБКА: local уничтожен, представление висячее!
}

Также остерегайтесь представлений над временными объектами, созданными посреди конвейера:

// НЕПРАВИЛЬНО: строка — временный объект, который уничтожается
auto words = std::string("hello world")
    | std::views::split(' ');  // висячее!

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

Лучшая практика

Представления ленивы — никакая работа не выполняется до итерации. Это означает:

1. Построение конвейера практически бесплатно (просто сохраняет указатели на функции и параметры)
2. Можно создавать представления над очень большими или даже бесконечными диапазонами
3. Каждый элемент проходит через весь конвейер перед обработкой следующего
4. Представления с коротким замыканием вроде take(n) останавливают весь конвейер после n элементов

Для материализации результатов представления в контейнер итерируйте и собирайте:

std::vector<int> results;
for (int x : some_view) results.push_back(x);

// C++23 добавляет std::ranges::to для более чистой материализации:
auto results = some_view | std::ranges::to<std::vector>();

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

Ключевые выводы
  • Представления — невладеющие, O(1) копируемые, лениво вычисляемые адаптеры диапазонов
  • views::filter и views::transform — фундаментальные строительные блоки конвейеров данных
  • views::take(n) и views::drop(n) обеспечивают нарезку без копирования
  • views::iota генерирует последовательности — ограниченные или неограниченные — заменяя циклы со счётчиком
  • Оператор pipe | компонует представления в читаемые конвейеры слева направо без промежуточных выделений памяти
  • Представления не должны переживать свои исходные данные — всегда убеждайтесь, что базовый диапазон имеет достаточное время жизни

Тест — проверьте свои знания

(20 XP)

1. Когда представление C++20 вычисляет свои элементы?

2. Каков результат `std::views::iota(1) | std::views::take(3)`?

3. Почему опасно создавать представление над локальной переменной и возвращать его из функции?

Назад
C++20 Ranges: новая парадигма
Далее
Исключения: throw, try, catch