‼️ Задача на выходные

Этот код содержит баг. Необходимо найди его:

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

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

    auto sorted_view = vec
        | std::views::transform([](int x) { return x; });

    std::ranges::sort(sorted_view);

    for (auto v : sorted_view) {
        std::cout << v << " ";
    }
}

Подсказка: views::transform возвращает prvalue. Можно ли сортировать такой view?

Отсортируется ли vec? Если нет — какая ошибка компиляции и почему?


📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#междусобойчик

😎 Знакомьтесь с экспертом Proglib.academy: AI-архитектор Андрей Носов

Андрей — один из ключевых спикеров нашего курса AgentOps. Он выстраивает архитектуру, которая выживает в суровом проде и активно делится своим опытом.

За что его ценит IT-комьюнити:

🟣 Топ-спикер AI Conf 2026

Его доклад про мифы семантического поиска и провалы Naive RAG стал одним из самых рейтинговых на конференции.

🟣 Эксперт по GraphRAG и Knowledge Graphs

Андрей внедряет инженерный подход в сложные системы, заменяя «слепую веру» в эмбеддинги строгой логикой графов.

🟣 Автор «14 кругов ада для RAG»

Разработал уникальный набор из 14 unit-тестов, на которых ломается стандартный векторный поиск (от слепоты к отрицаниям до конфликта версий).

🟣 Спикер Saint HighLoad

Регулярно выступает на крупнейших хайлоад-площадках, разбирая архитектуру отказоустойчивых ИИ-сервисов.

Андрей упаковал свои наработки в Google Colab, где можно пощупать 14 сценариев ошибок RAG и их решения:

🔗 Забрать Colab-ноутбук

На курсе Андрей отвечает за самые «мясные» блоки: RAG, оркестрацию агентов и их промышленную эксплуатацию.

Узнать больше о программе и обучении у Андрея:
👉 Курс о том, как внедрять AI-логику в бэкенд и сохранять стабильность сервиса

Так, продолжаем знакомить вас с командой?
👍 — Да, ждем новых лиц
🔥 — Пойду тестить Colab Носова

🥨 Вложенные диапазоны: views::join и views::join_with

Сегодня научимся работать с вложенными — «сплющивать» диапазон диапазонов в один поток и вставлять разделители между ними.


☂️ views::join — «сплющить» диапазон диапазонов

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

// Объединяем все подвекторы в один поток
for (int x : matrix | views::join) {
    std::cout << x << " "; // 1 2 3 4 5 6 7 8 9
}

Классический кейс — обход всех элементов матрицы без вложенных циклов. join работает с любым диапазоном, элементы которого сами являются диапазонами: vector<vector<T>>, vector<string>, результат views::split и т.д.

std::string csv = "10,20,30";

// split разбивает → join склеивает обратно (без разделителя)
for (char c : csv | views::split(',') | views::join) {
    std::cout << c; // 102030
}

❗️ Важный нюанс: в C++20 views::split возвращает подиапазоны, тип которых отличается от string_view. В C++23 поведение split было пересмотрено, а прежняя версия переименована в views::lazy_split. Если работаете со строками в C++20, имейте это в виду.


🍴 Какую категорию итераторов даёт join?

Это зависит от исходного диапазона:
• если внешний и внутренний диапазоны моделируют forward_range (как vector<vector<int>>), результат join тоже будет forward_range
• итераторы валидны, многопроходность гарантирована
• если оба моделируют bidirectional_range и внутренний при этом common_range, результат может быть bidirectional_range
• если внешний диапазон — всего лишь input_range (например, поток), результат join — тоже input_range, и тогда проходить его можно только линейно, в один проход

❗️ Категория результата определяется самым «слабым» из участников.


🧋 views::join_with — объединить с разделителем (C++23)

std::vector<std::string> words = {"один", "два", "три"};

// Вставляем пробел между словами
for (char c : words | views::join_with(' ')) {
    std::cout << c;
}
// один два три

Разделителем может быть не только один элемент, но и целый диапазон:

std::vector<std::string> parts = {"SELECT *", "FROM users", "WHERE id = 1"};

for (char c : parts | views::join_with(std::string_view{"\n  "})) {
    std::cout << c;
}
// SELECT *
//   FROM users
//   WHERE id = 1

❗️ join_with требует, чтобы тип разделителя был совместим с внутренним типом элементов. Если у вас vector<vector<int>>, разделитель — int или диапазон int, а не string. Компилятор скажет об этом длинной шаблонной ошибкой — ищите в ней range_value_t.


🩹 Комбинация с другими views

Настоящая сила раскрывается в цепочках:

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

// Сплющить → оставить чётные → взять первые 3
auto result = grid
    | views::join
    | views::filter([](int x) { return x % 2 == 0; })
    | views::take(3);

for (int x : result) {
    std::cout << x << " "; // 2 4 6
}

Ни одного промежуточного контейнера — всё вычисляется поэлементно.


🍋 Главное свойство

Как и все views, join и join_with ленивые — они не копируют внутренние диапазоны и не выделяют память. Элементы «вытягиваются» по одному при итерации. Но у этой лени есть цена: join над input_range даёт только input_range, поэтому отсортировать результат напрямую не получится — сначала материализуйте через ranges::to<vector>() (C++23).


📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#константная_правильность

🔥 Препроцессор C++ — наследие, от которого не сбежать

Несмотря на все усилия комитета по стандартизации, #include и #define по-прежнему живут в каждом проекте. Препроцессор — это, по сути, отдельный язык, работающий до компиляции, и он ничего не знает о типах, областях видимости и прочих правилах C++.

Главная проблема — текстовая подстановка. Макрос не проверяет типы, не уважает пространства имён и может сломать код в самом неожиданном месте. Классический пример: #define max(a,b) ((a)>(b)?(a):(b)) — попробуйте передать туда i++, и получите двойной инкремент.

Современный C++ предлагает альтернативы почти для каждого сценария: constexpr, consteval, inline-функции, шаблоны. Но полностью убить препроцессор пока не удалось.


✏️ А в вашем проекте много макросов, или удалось от них почти избавиться?


📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#междусобойчик

🍳 Ranges: другие полезные адаптеры

В прошлый раз мы разобрали views::join и views::join_with — «сплющивание» вложенных диапазонов. Сегодня — подборка адаптеров, которые пригождаются постоянно, но о которых часто забывают.


🍒 views::reverse — обратный порядок

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

❗️ Требует bidirectional_range. Например, views::filter моделирует bidirectional_range, только если исходный диапазон сам bidirectional_range и common_range — так что для vector, deque или list цепочка views::filter(...) | views::reverse работает, а для forward_list или istream_view — нет.


🏝 views::keys и views::values — для пар и map

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
}

Под капотом views::keys — это views::elements<0>, а views::values — views::elements<1>. Работает с любым диапазоном, элементы которого моделируют std::pair или std::tuple-подобный тип.


🍍 views::elements<N> — N-й элемент tuple/pair

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
}

Обобщённая версия keys/values — извлекает элемент с индексом N из каждого кортежа. Индекс задаётся на этапе компиляции, поэтому выход за границы — ошибка компиляции, а не UB.


🍕 views::counted — N элементов начиная с итератора

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

В отличие от views::take, который работает с диапазоном, counted принимает итератор + количество. Это незаменимо, когда у вас «голый» итератор без парного end — например, указатель указатель на элемент C-массива или результат std::find.

❗️ Ответственность за то, что it + n не выходит за пределы, лежит на вас — проверки в рантайме нет.


🍿 views::all — обернуть в view явно

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

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

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

Зачем нужен, если | и так оборачивает? Бывает полезно при передаче контейнера в функцию, которая принимает viewable_range, или для хранения view в переменной без auto&&. На практике views::all вызывается неявно почти в каждой цепочке — но иногда явный вызов делает код яснее.


🍋 views::common — сделать begin/end одного типа

Многие «классические» алгоритмы и конструкторы контейнеров ожидают, что begin() и end() возвращают один и тот же тип. У ленивых view это часто не так — end() может вернуть sentinel, а не итератор.

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

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

❗️ Если диапазон уже common_range, адаптер ничего не делает — просто пробрасывает как есть. Накладных расходов в этом случае ноль.


🩹 Комбинируем всё вместе

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
}

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


📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#константная_правильность