C++

Pohledy, líné hodnocení a kompozice

Pohledy Master C++20 — lehké, líné adaptéry dosahu, které se skládají s obsluhou potrubí. Naučte se filtrovat, transformovat, brát, upouštět, rozdělovat, spojovat, iota a jak budovat výkonné datové kanály bez přechodných alokací.

Co jsou zobrazení?

view je lehká řada, která je:

1. Nevlastnící – nevlastní prvky, na které odkazuje
2. O(1) kopírovat a přesouvat — pohledy jsou levné na přecházení
3. Líně vyhodnoceno — prvky se počítají na vyžádání během iterace, nikoli předem

Pohledy jsou stavebními kameny dálkovodů. Namísto vytváření přechodných kontejnerů v každém kroku se pohledy skládají do jediného průchodu daty:

// Traditional: creates 2 intermediate vectors
auto evens = filter(data, is_even);     // allocation
auto squared = transform(evens, sq);    // allocation

// Views: zero intermediate allocations
auto result = data | views::filter(is_even) | views::transform(sq);
// Nothing computed yet — result is just a view descriptor
for (int x : result) { ... }  // computed element-by-element

Views live in std::zobrazení:: (a namespace alias for std::rozsahy::zobrazení::).

filtrovat a transformovat — Základní pohledy

views::filterzachovává prvky odpovídající predikátu.views::transformaplikuje funkci na každý prvek. Společně nahrazují většinu explicitních smyček.

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>();
}

zobrazení vzít, upustit a krájet

views::take(n)poskytuje prvních n prvků.views::drop(n)přeskočí prvních n prvků. Společně umožňují efektivní krájení bez kopírová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';
}

zobrazení rozdělení, spojení a zpracování řetězců

views::splitdělí rozsah oddělovačem.views::joinvyrovná vnořené rozsahy. Jsou výkonné pro zpracování řetězců a dat.

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 — Generování rozsahů

views::iotageneruje sekvenci zvyšujících se hodnot. Může být ohraničený (iota(0, 10)pro 0..9) nebo neomezený (iota(0)pro 0, 1, 2, ...). V kombinaci stakenahrazuje mnoho počítacích smyček.

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
}

Budování kompletních datových kanálů

Skutečná síla pohledů se ukáže, když složíte více adaptérů do jednoho potrubí. Celé potrubí se vyhodnocuje líně v jediném průchodu.

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';
    }
}
Úskalí

Pohledy nevlastní – odkazují na základní rozsah. Pokud se zdrojový rozsah zničí, pohled bude visící:

auto make_view() {
    std::vector<int> local = {1, 2, 3};
    return local | std::views::filter([](int x) { return x > 1; });
    // BUG: local is destroyed, view dangles!
}

Also beware of views over temporaries created mid-pipeline:

// WRONG: the string is a temporary that gets destroyed
auto words = std::string("hello world")
    | std::views::split(' ');  // dangling!

Vždy se ujistěte, že zdrojová data přežijí všechny pohledy, které na ně odkazují. Před vytvořením zobrazení uložte data do proměnné s dostatečnou životností.

Osvědčený postup

Zobrazení jsou líná — až do iterace neproběhne žádná práce. To znamená:

1. Vytvoření potrubí je v podstatě zdarma (ukládá pouze ukazatele funkcí a parametry)
2. Můžete vytvářet pohledy na velmi velké nebo dokonce nekonečné rozsahy
3. Každý prvek protéká celým potrubím, než se zpracuje další prvek
4. Zkratovací pohledy jakotake(n)zastaví celé potrubí po n prvcích

Chcete-li zhmotnit výsledky zobrazení do kontejneru, iterujte a shromážděte:

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

// C++23 adds std::ranges::to for cleaner materialization:
auto results = some_view | std::ranges::to<std::vector>();

Upřednostňujte uchování dat jako zobrazení tak dlouho, jak je to možné – zhmotní se pouze tehdy, když potřebujete náhodný přístup, trvalost nebo je předávat rozhraním API, která vyžadují kontejnery.

Klíčové poznatky
  • Pohledy jsou nevlastní, O(1) kopírovatelné, líně hodnocené adaptéry rozsahu
  • views::filteraviews::transformjsou základní stavební bloky pro datové kanály
  • views::take(n)aviews::drop(n)poskytují krájení bez kopírování
  • views::iotageneruje sekvence — ohraničené nebo neohraničené — nahrazující počítací smyčky
  • Operátor kanálu|skládá pohledy do čitelných kanálů zleva doprava s nulovými mezilehlými alokacemi
  • Views must not outlive their source data — always ensure the underlying range has sufficient lifetime

Kvíz — Otestujte své znalosti

(20 XP)

1. Kdy pohled C++20 počítá své prvky?

2. What is the result of`std::views::iota(1) | std::views::take(3)`?

3. Proč je nebezpečné vytvořit pohled na lokální proměnnou a vrátit ji z funkce?

Předchozí
Rozsahy C++20: Nové paradigma
Další
Výjimky: hodit, zkusit, chytit