std::vector<int> v = {1, 2, 3, 4, 5};
for (int x : v | views::reverse) {
    std::cout << x << " "; // 5 4 3 2 1
}

std::map<std::string, int> ages = {{"Алиса", 30}, {"Борис", 25}};

for (const auto& name : ages | views::keys) {
    std::cout << name << "\n"; // Алиса, Борис
}

for (int age : ages | views::values) {
    std::cout << age << "\n"; // 30, 25
}

std::vector<std::tuple<int, std::string, double>> records = {
    {1, "Alice", 3.14},
    {2, "Bob",   2.71},
};

// Берём только строки (индекс 1)
for (const auto& s : records | views::elements<1>) {
    std::cout << s << "\n"; // Alice, Bob
}

std::vector<int> v = {10, 20, 30, 40, 50};
auto it = v.begin() + 1; // указывает на 20

// 3 элемента начиная с позиции 1
auto three = views::counted(it, 3);
// 20, 30, 40

std::vector<int> v = {1, 2, 3};

// views::all явно создаёт view из контейнера
auto all_view = views::all(v);

// Это полезно при передаче в функции, ожидающие view

auto view = some_range | views::filter(...);

// Если нужно передать в старый алгоритм, требующий итераторов одного типа:
auto common_view = view | views::common;
std::copy(common_view.begin(), common_view.end(), output);

std::map<std::string, std::vector<int>> data = {
    {"alpha", {1, 2, 3}},
    {"beta",  {4, 5}},
    {"gamma", {6, 7, 8, 9}},
};

// Все значения → сплющить → обратный порядок → первые 4
auto result = data
    | views::values
    | views::join
    | views::reverse
    | views::take(4);

for (int x : result) {
    std::cout << x << " "; // 9 8 7 6
}

#include <mutex>
#include <thread>
#include <vector>
#include <iostream>

std::mutex mtx;
std::vector<int> data;

void producer() {
    for (int i = 0; i < 100; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        data.push_back(i);
    }
}

void consumer() {
    while (true) {
        std::lock_guard<std::mutex> lock(mtx);
        if (data.empty()) {
            // Ждём данные...
            std::this_thread::sleep_for(
                std::chrono::milliseconds(10));
            continue;
        }
        std::cout << data.back() << "\n";
        data.pop_back();
    }
}

std::vector<int> v = {3, 1, 4, 1, 5, 9, 2, 6};

// Найти первый элемент, равный 4
auto it = std::ranges::find(v, 4);
if (it != v.end()) {
    std::cout << "Найдено: " << *it << "\n"; // 4
}

// Найти первый элемент, удовлетворяющий условию
auto it2 = std::ranges::find_if(v, [](int x) { return x > 5; });
// указывает на 9

std::vector<int> v = {3, 1, 4, 1, 5, 9, 2, 6};

bool all_positive = std::ranges::all_of(v, [](int x) { return x > 0; });
// true — все элементы положительные

bool any_gt_8 = std::ranges::any_of(v, [](int x) { return x > 8; });
// true — есть 9

bool none_neg = std::ranges::none_of(v, [](int x) { return x < 0; });
// true — отрицательных нет

auto count_ones = std::ranges::count(v, 1);       // 2
auto count_big  = std::ranges::count_if(v, [](int x) { return x > 5; }); // 2 (9, 6)

auto [min_it, max_it] = std::ranges::minmax_element(v);
std::cout << *min_it << " " << *max_it; // 1 9

struct Person {
    std::string name;
    int age;
};

std::vector<Person> people = {{"Алиса", 30}, {"Борис", 25}, {"Вера", 35}};

// Найти человека по имени — без лямбды!
auto it = std::ranges::find(people, "Борис", &Person::name);
// it->age == 25

// Самый молодой
auto youngest = std::ranges::min_element(people, {}, &Person::age);
// youngest->name == "Борис"

// Все ли совершеннолетние?
bool all_adults = std::ranges::all_of(people, [](int a) { return a >= 18; }, &Person::age);

std::map<std::string, std::vector<int>> data = {
    {"alpha", {1, 2, 3}},
    {"beta",  {4, 5}},
    {"gamma", {6, 7, 8, 9}},
};

// Сколько значений больше 5 во всех векторах?
auto all_values = data | views::values | views::join;
auto count = std::ranges::count_if(all_values, [](int x) { return x > 5; });
// 4 (6, 7, 8, 9)