💡 __has_include() — это не проверка заголовка, а запрос к препроцессору

Если думал, что __has_include(<vector>) проверяет «существует ли файл на диске». Это не так. Директива работает на уровне препроцессора и взаимодействует с поисковыми путями компилятора, а не с файловой системой напрямую.

🔍 Как это работает

__has_include — это расширение препроцессора, стандартизированное в C++17. Когда компилятор встречает:

#if __has_include(<optional>)
#  include <optional>
#endif

— препроцессор проходит по своим include-путям (-I, системные пути, -isystem) и проверяет, разрешится ли имя файла в один из них. Это тот же механизм, что используется при обычном #include, но без реальной вставки содержимого.

🏝 Два синтаксиса — два алгоритма поиска

__has_include(<header>)   // поиск только в системных путях
__has_include("header")   // поиск сначала в локальных, затем в системных

Это зеркалит поведение обычных #include <> и #include "". Разница критична при наличии локальных заголовков с теми же именами, что и системные.

❗️ Ловушка: наличие != доступность

Файл может быть найден препроцессором, но при этом не компилироваться на данной платформе. Например, <windows.h> физически присутствует в MinGW, но использование некоторых его частей невозможно без нужного таргета. __has_include вернёт 1, но код всё равно сломается.

‼️ Практический вывод

Используй __has_include для определения наличия необязательных зависимостей, но всегда дополняй проверкой версии или feature-теста (__cpp_lib_optional). Это защитит от ситуации «файл есть, фича недоступна».


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

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

#под_капотом

👩‍💻 #include хотят переименовать в #please

Комитет ISO пришёл к выводу, что вежливое обращение к компилятору снижает количество ошибок компиляции на 12%.

#please <iostream>
#please <vector>

❗️ Компилятор тоже заслуживает уважения.

Попались? С первым апреля! 😁


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

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

#развлекалово

🥳 C++ Ranges. Часть 1: Основы

«Если ты думаешь, что циклы — это нормально, ты просто ещё не видел Ranges»
— Каждый разработчик C++20, примерно через неделю после знакомства с библиотекой

🌸 Введение

Добро пожаловать в мир C++ Ranges — одного из самых мощных нововведений стандарта C++20.

Если ты когда-нибудь писал вот такой код:

std::vector<int> result;
for (const auto& x : data) {
  if (x % 2 == 0) {
    result.push_back(x * x);
  }
}

..то ты знаешь, как это может быть многословно. Ranges позволяют написать то же самое так:

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

Красиво? Ещё и эффективнее! Давай разберёмся, как это работает.


🍴 Что нам понадобится

Для работы со всеми примерами нужен компилятор с поддержкой C++20 (и лучше C++23):

#include <ranges> // std::views, std::ranges::*
#include <algorithm> // std::ranges::sort и другие

1️⃣ Что такое Range?

Range (диапазон) — это любой тип, у которого есть начало ( begin ) и конец ( end ). Всё, что ты
привык итерировать в цикле for , уже является диапазоном.

std::vector<int> v = {1, 2, 3, 4, 5}; // ✓ Range
std::string s = "hello";              // ✓ Range
int arr[] = {1, 2, 3};                // ✓ Range
std::list<double> l = {1.1, 2.2};     // ✓ Range

С технической точки зрения, тип R является диапазоном, если для него определены
std::ranges::begin(r) и std::ranges::end(r) . В C++ это выражается через концепт:

template<typename R>
concept range = requires(R& r) {
  std::ranges::begin(r); // требуем наличие begin
  std::ranges::end(r); // требуем наличие end
};

🍪 Категории диапазонов

• input_range — однопроходный обход (Пример: поток ввода)
• forward_range — многопроходный обход (Пример: std::forward_list)
• bidirectional_range — обход в обе стороны (Пример: std::list)
• random_access_range — доступ за O(1) по индексу (Пример: std::deque)
• contiguous_range — данные в непрерывной памяти (Пример: std::vector , массив)


🐸 Продолжение следует... Дальше разберём, какие алгоритмы можно использовать с Ranges.

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

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

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

🍿 C++ Ranges. Views и алгоритмы

Продолжаем тему Ranges в C++.

В библиотеке Ranges есть два главных инструмента работы с последовательностями:

1. std::ranges::* алгоритмы — переработанная версия классической библиотеки <algorithm>. Принимают не пару итераторов, а целый диапазон, поддерживают проекции и лучше взаимодействуют с современными типами.

2. std::views::* адаптеры — ленивые обёртки над диапазонами. Не копируют данные, а описывают как их обойти. Удобны для цепочек преобразований.


🐤 Старый стиль vs новый стиль

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

// Старый стиль: передаём пару итераторов
std::sort(v.begin(), v.end());

// Новый стиль: передаём весь диапазон
std::ranges::sort(v);

❗️Разница кажется небольшой, но новый стиль:

• Синтаксически короче
• Поддерживают проекции — сортировку по произвольному полю объекта
• Работают с любым range-совместимым типом, не только с контейнерами


✅ Пример 1. Cортировка

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

int main() {
    std::vector<std::string> names = {"Boris", "Anton", "Victor", "Anna"};

    std::ranges::sort(names);

    for (const auto& name : names) {
        std::cout << name << "\n";
    }
    // Anna, Anton, Boris, Victor
}

✅ Пример 2. Проекции — сортировка по полю структуры

Одна из главных фич ranges-алгоритмов. Не нужно писать лямбду вручную — достаточно указать, по какому полю сортировать:

#include <algorithm>
#include <vector>
#include <iostream>
#include <string>

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

int main() {
    std::vector<Person> people = {
        {"Boris", 30},
        {"Anna", 25},
        {"Victor", 35}
    };

    // Сортируем по возрасту, передав &Person::age как проекцию
    std::ranges::sort(people, {}, &Person::age);

    for (const auto& p : people) {
        std::cout << p.name << " " << p.age << "\n";
    }
    // Anna 25, Boris 30, Victor 35
}

✅ Пример 3. Views — ленивые цепочки

std::views не трогают исходный контейнер и не создают копий — они описывают трансформацию, которая применяется при обходе:

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

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

    // Берём только чётные, умножаем на 10, берём первые 3
    auto result = v
        | std::views::filter([](int x) { return x % 2 == 0; })
        | std::views::transform([](int x) { return x * 10; })
        | std::views::take(3);

    for (int x : result) {
        std::cout << x << "\n";
    }
    // 20, 40, 60
}

❗️Исходный вектор v не изменился. Весь пайплайн вычисляется лениво — только когда мы итерируемся в цикле.


🐸 Продолжение следует... В следующий раз разбираем pipelines

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

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

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

🩹 C++ Ranges. Конвейеры: оператор |

То, ради чего стоит использовать Ranges — это конвейеры (pipelines). Оператор | позволяет обрабатывать данные через цепочку преобразований:

🥲 Как это выглядело до C++20:

std::vector<int> temp, result;
std::copy_if(numbers.begin(), numbers.end(), std::back_inserter(temp),
             [](int n) { return n % 2 == 0; });
std::transform(temp.begin(), temp.end(), std::back_inserter(result),
               [](int n) { return n * n; });

❗️ Вложенные алгоритмы, временные буферы, много шума.


🙂 С конвейером (C++20):

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

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

    // Конвейер: фильтруем чётные → возводим в квадрат → берём первые 3
    auto result = numbers
        | std::views::filter([](int n) { return n % 2 == 0; })
        | std::views::transform([](int n) { return n * n; })
        | std::views::take(3);

    for (int x : result) {
        std::cout << x << " "; // 4 16 36
    }
    std::cout << "\n";
}

❗️ result — это не вектор, а «вид» (view). Вычисления происходят лениво — только в момент итерации в цикле for. Исходный вектор numbers остаётся нетронутым.

❓ Нужен именно вектор? Материализуйте результат:

// C++23
auto vec = result | std::ranges::to<std::vector>();

// C++20
std::vector<int> vec(result.begin(), result.end());

🐸 Продолжение следует...


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

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

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

🔥 Найди баг: копирование строки сломало указатель

#include <string>
#include <iostream>

struct Token {
    std::string value;
    const char* ptr;

    Token(const std::string& s) : value(s), ptr(value.data()) {}
};

int main() {
    Token t1("hi");
    Token t2 = t1; // копируем

    std::cout << t1.ptr << "\n"; // "hi"
    std::cout << t2.ptr << "\n"; // ???
}

‼️ Задача: найди баг (если он есть), объясни, почему он связан с SSO, и предложи исправление.

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

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

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

🍙 C++ Ranges. Ленивые вычисления (C++20)

Cамое важное свойство адаптеров views: они ленивые (lazy).

Когда ты пишешь data | views::filter(...) | views::transform(...), ты не запускаешь обработку. Ты создаёшь лёгкий view-объект, который хранит ссылку на исходный диапазон и предикаты. Обработка происходит только тогда, когда ты начинаешь итерировать результат — поэлементно, по требованию.

⚠️ Важно: view хранит ссылку на исходный контейнер. Если контейнер изменится или выйдет из области видимости раньше, чем ты начнёшь итерацию — поведение будет неопределённым.

🌸 Пример 1: базовая ленивость

// C++20
#include <vector>
#include <ranges>
#include <iostream>

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

    // Создаём view — никакой обработки ещё нет
    auto view = v | std::views::filter([](int x) {
        std::cout << "Проверяем " << x << "\n";
        return x > 2;
    });

    std::cout << "Начинаем итерацию:\n";
    for (int x : view) {
        std::cout << "Результат: " << x << "\n";
    }
}

❗️Вывод — фильтрация и результат чередуются поэлементно. Это и есть ленивость в действии:

Начинаем итерацию:
Проверяем 1
Проверяем 2
Проверяем 3
Результат: 3
Проверяем 4
Результат: 4
Проверяем 5
Результат: 5

Сравни с тем, как выглядел бы «жадный» (eager) подход: сначала все "Проверяем...", потом все "Результат:". Здесь же — один элемент за раз.

🌱 Пример 2: цепочка адаптеров

Можно выстраивать цепочки — каждый адаптер обрабатывает элемент по мере продвижения итератора:

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

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

    auto view = v
        | std::views::filter([](int x) { return x % 2 == 0; })  // только чётные
        | std::views::transform([](int x) { return x * x; });   // возводим в квадрат

    for (int x : view) {
        std::cout << x << " ";  // 4 16 36 64 100
    }
}

Здесь transform никогда не видит нечётных чисел — filter не пропускает их дальше. Никаких промежуточных векторов, никаких лишних аллокаций.


🌳 Пример 3: ранняя остановка

Ленивость особенно выгодна, когда тебе не нужны все элементы. views::take берёт ровно столько, сколько нужно, и останавливает обработку:

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

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

    // Берём первые 3 чётных числа — и всё, остальные даже не проверяются
    auto view = v
        | std::views::filter([](int x) {
            std::cout << "Проверяем " << x << "\n";
            return x % 2 == 0;
        })
        | std::views::take(3);

    for (int x : view) {
        std::cout << "Берём: " << x << "\n";
    }
}

Вывод:

Проверяем 1
Проверяем 2
Берём: 2
Проверяем 3
Проверяем 4
Берём: 4
Проверяем 5
Проверяем 6
Берём: 6
Проверяем 7 // Могут быть проверены (зависит от компилятора)
Проверяем 8 // хотя это не обязательно

После шестёрки обработка полностью прекращается. Числа 7–10 не тронуты — хотя они есть в векторе.


💡 Итоги

Ленивость — это не просто деталь реализации. Это архитектурное свойство, которое позволяет:

• работать с бесконечными диапазонами (std::views::iota)
• не создавать промежуточные контейнеры при цепочках
• останавливать обработку раньше, как только результат получен

Плата за это — view не кэширует результаты. Если ты итерируешь view дважды, предикаты выполнятся дважды. Если это проблема — преврати результат в вектор через std::ranges::to<std::vector>() (C++23) или просто std::vector(view.begin(), view.end()).


🐸 Продолжение следует...


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

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

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

🌳 std::call_once и once_flag: явная ленивая инициализация

Иногда нужно инициализировать ресурс ровно один раз, но логика инициализации сложнее, чем в конструкторе. Вот инструмент для этого.

#include <mutex>
#include <memory>

class ResourceManager {
    std::once_flag init_flag_;
    std::unique_ptr<HeavyResource> resource_;

public:
    // once_flag нельзя копировать — явно запрещаем копирование класса
    ResourceManager() = default;
    ResourceManager(const ResourceManager&) = delete;
    ResourceManager& operator=(const ResourceManager&) = delete;

    HeavyResource& get_resource() {
        std::call_once(init_flag_, [this] {
            // Выполнится ровно один раз, даже при гонке потоков.
            // Если инициализация бросит исключение — флаг не выставится,
            // и следующий поток повторит попытку.
            resource_ = std::make_unique<HeavyResource>(load_config());
        });
        return *resource_;
    }
};

// Использование — просто и безопасно
ResourceManager mgr;
auto& r1 = mgr.get_resource(); // инициализирует
auto& r2 = mgr.get_resource(); // возвращает готовый

💡 Когда call_once лучше Meyers Singleton (static local-переменной):

• Инициализация — отдельный этап от конструктора объекта
• Нужно явно контролировать момент инициализации, а не привязывать его к первому обращению к static-переменной
• Логика инициализации требует захвата внешнего состояния (this, параметры)

📊 Оверхед call_once после первого вызова — минимален, но не нулевой: как минимум одна атомарная проверка с барьером памяти. Стоит замерить бенчмарком.

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

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

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

🍿 std::views::filter — ленивая фильтрация в C++20

Адаптеры std::views::* — главный инструментарий Ranges. Каждый из них создаёт новое «представление» существующих данных без копирования. Сегодня разберём views::filter.


🌸 Базовое использование

#include <ranges>
#include <vector>
namespace views = std::views;

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

auto positives = nums | views::filter([](int x) { return x > 0; });
// Итерация даёт: 1, 3, 5

Ничего не копируется — positives это просто обёртка поверх nums, которая позволяет удобно обрабатывать его элементы.


🍪 Цепочка фильтров

auto is_even = [](int x) { return x % 2 == 0; };

auto result = nums
    | views::filter([](int x) { return x > 0; })  // 1, 3, 5
    | views::filter(is_even);                     // нет чётных → пусто

Фильтры можно комбинировать в произвольную цепочку. Вычисление происходит лениво — только в момент итерации.


👻 Композиция с views::transform

Достаточно просто ограничить обработку только тех элементов, которые хотим обработать:

auto squares = nums
    | views::filter([](int x) { return x > 0; })
    | views::transform([](int x) { return x * x; });
// Итерация даёт: 1, 9, 25

🍙 Материализация в вектор

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

// C++23
auto vec = nums | views::filter(is_even) 
               | std::ranges::to<std::vector>();

// C++20
std::vector<int> vec(result.begin(), result.end());

🌱 Pipe-синтаксис vs явный тип

Синтаксис в виде pipe удобе, но если необходимо (например, для шаблонов), то можно пользоваться диапазонами как типами/объетами. Обе записи идентичны:

auto v1 = nums | views::filter(is_even);
auto v2 = std::ranges::filter_view{nums, is_even};

❗️ Ловушка: dangling view

// UB — вектор уничтожен после точки с запятой
auto bad = std::vector{1, 2, 3} | views::filter(is_even);

// Правильно — храните источник данных отдельно
std::vector<int> data = {1, 2, 3};
auto ok = data | views::filter(is_even);

🐸 Продолжение следует...

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

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

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