Библиотека C/C++ разработчика | cpp, boost, qt

📍Навигация: Вакансии • Задачи • Собесы Библиотека 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++ разработчика #константная_правильность

🍙 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++ разработчика #константная_правильность

😎 Топ-вакансий для C++ разработчиков за неделю C/C++ разработчик — от 400 000 и до 600 000 ₽ Офис (Санкт-Петербург) C++/Qt/QML-разработчик — от 250 000 ₽ Удалёнка Developer C++ (KSMG) — Удалёнка ✍️ Еще больше топовых вакансий — в нашем канале C++ jobs 📍Навигация: Вакансии • Задачи • Собесы Библиотека C/C++ разработчика #буст

Podlodka Deep Dive #1 – С++ Антон Полухин – член комитета по стандартизации C++, что делает его одним из тех людей, кто решает, каким будет C++ в будущем. При этом Антон пишет на C++ высоконагруженный код каждый день в техплатформе городских сервисов Яндекса. Еще он – создатель и активный ментейнер многих библиотек Boost, и автор книги «Boost C++ Application Development Cookbook». C++ пинают все кому не лень – от госдепа США до российских студентов, которые со страхом вспоминают лабы на нем. При этом язык по-прежнему живет везде: системное программирование, игровые движки, финтех, embedded, браузеры. Почему так? Почему у него такая репутация, откуда взялось столько плохого кода, и чем вообще виноваты шаблоны C++? Вместе с Антоном мы разбираем новые стандарты C++ и главные направления развития языка: безопасность, рефлексию, модули, стандартную библиотеку. Антон рассказывает не только про то, что появится в языке, но и какие реальные проблемы за этим стоят. Отдельно спорим про C++ vs Rust: нужен ли C++ borrow checker, можно ли догнать Rust по безопасности и стоит ли вообще это делать. Ну и конечно говорим про то, что ждет язык через 10 лет, является ли темп обновления стандартов плюсом, насколько больно мигрировать продуктовый код и является ли обратная совместимость достоинством или проклятием. 🎧 Слушать выпуск 👀 Смотреть выпуск

🍴 Почему constexpr вычисляется не всегда в compile-time Считается что constexpr — значит всё вычислится на этапе компиляции. Это заблуждение регулярно приводит к сюрпризам в production-коде. ✏️ Что говорит стандарт constexpr-функция обязана вычислиться в compile-time, если её результат используется там, где требуется константное выражение. Если же аргументы известны только в runtime — функция выполнится как обычная.

constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

constexpr int a = factorial(5);  // compile-time: аргумент константный
int n = 5;
int b = factorial(n);            // runtime: n не константное выражение

⚡️ Как гарантировать compile-time вычисление Присвойте результат в constexpr-переменную или используйте как аргумент шаблона. Если компилятор не ругается — вычислилось в compile-time. static_assert тоже работает.

// Гарантированный compile-time:
constexpr int val = factorial(10);  // ошибка компиляции, если невозможно
static_assert(factorial(5) == 120);  // тоже гарантия

// НЕ гарантия по стандарту, но на практике
// все современные компиляторы вычислят в compile-time:
const int val2 = factorial(10);   // GCC/Clang/MSVC → compile-time

Локальная constexpr-переменная не обязательно попадает в .rodata — она может быть оптимизирована в регистр или immediate-операнд. В .rodata она окажется только если берётся её адрес или она имеет статическую длительность хранения.

‼️ std::is_constant_evaluated() (C++20) и if consteval (C++23) Позволяют внутри функции понять, в каком контексте она выполняется, и разветвить логику. Но у std::is_constant_evaluated() есть классическая ловушка:

// Ловушка: b всегда будет true — is_constant_evaluated()
// смотрит на контекст инициализации самой переменной b
constexpr bool trap() {
    return std::is_constant_evaluated();
}

// if consteval лишён этой проблемы — это языковая конструкция:
constexpr double sqrt_impl(double x) {
    if consteval {
        // compile-time версия (метод Ньютона и т.д.)
        return newton_sqrt(x);
    } else {
        return std::sqrt(x);  // runtime — используем либо
    }
}

🐸 Вывод Хочешь гарантии compile-time — используй consteval (C++20). Он запрещает вызов функции в runtime-контексте и даёт ошибку компиляции. А constinit (C++20) пригодится, когда нужна гарантия инициализации в compile-time, но переменная не должна быть const. 📍Навигация: Вакансии • Задачи • Собесы Библиотека C/C++ разработчика #под_капотом

🌱 Как техлиду перестать быть справочником и научить своих аналитиков самостоятельности Вступив в должность техлида, я глубоко погружалась во все процессы, чтобы быстро встроиться в контекст и помогать команде. Но со временем стала замечать, что вопросы моих ребят становились всё проще. Переломным моментом стал запрос сеньор-аналитика, который через год пришёл с вопросом «А как смотреть логи?». Но проблема была не в компетенциях, а всамом формате взаимодействия, где команда привыкает полагаться на руководство вместо самостоятельного поиска решений. 👉 Статья 📍Навигация: Вакансии • Задачи • Собесы Библиотека C/C++ разработчика #свежак

🤯 Представьте, что ваш AI-агент работает так же предсказуемо, как обычный микросервис. Звучит утопически, но это именно то, к чему должна прийти разработка в 2026 году. Основная боль текущих реализаций — полная непредсказуемость поведения. Сегодня агент выполнил задачу за два шага, а завтра ушёл в рекурсию и потратил все лимиты. Наш обновлённый курс «Разработка AI-агентов» научит, как приручить этот хаос с помощью Python и современных фреймворков. Мы не будем учить «общаться» с нейросетью, мы будем строить из неё надёжный инструмент. ✅ Что вы получите: — понимание того, как управлять логикой агента на уровне кода; — навыки работы с LangChain и библиотеками оркестрации; — готовые паттерны для обработки ошибок и галлюцинаций; — опыт создания систем, которые реально экономят время. Есть пара мест со скидкой до завтра, решайтесь 👈🏻

🤔 Разрабатываете ИИ-агентов, но всё ещё не уверены в их стабильности и прогнозируемости? Мы поговорили с десятками разработчиков ИИ-агентов и сделали отдельный курс по AgentOps. 🧠 На нём вы узнаете: – как оптимизировать траты на токены; – как на практике оценить качество работы агента; – как «докручивать» RAG-системы без потери качества; – как обеспечить устойчивость агента к сбоям внешних сервисов без падения всей системы и про многое-многое другое. 📅 Старт: 19 мая. 👥 Спикеры — практики с опытом в AI и Data Science в крупных IT-компаниях, таких как Яндекс, Huawei, МТС и др. Длительность: 6-12 недель в зависимости от тарифа. 🔗 Программа курса и другие подробности

📰 Свеженькое из мира C++ Подготовили подборку самых интересных материалов за неделю о разных аспектах программирования и интересных проектах в мире C++. 😎 Интересное: • GDB: отладка без боли — вводная статья про использование GDB •std::rotate_copy — пример использования алгоритма rotate, но с выделением промежуточного буфера • C++26 официально готов! — наконец-то C++26, разбираем основные нововведения •Исходники Cfront — архив первоисточников по C++: от ранних технических отчётов Bell Labs до исходного кода транслятора Cfront всех релизов •quick-bench.com — онлайн-бенчмарк на базе Google Benchmark 📙 Ranges • C++ Ranges. Основы — начало цикла постов про использование ranges • C++ Ranges. Views и алгоритмы • C++ Ranges. Конвейеры: оператор | 🔹📍Навигация: Вакансии • Задачи • Собесы Библиотека 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++ разработчика #междусобойчик

🩹 Конвейеры: оператор | То, ради чего стоит использовать 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++ разработчика #константная_правильность

📍Навигация: Вакансии • Задачи • Собесы Библиотека C/C++ разработчика #развлекалово

😎 Бенчмарк прямо в браузере, без сборки проекта quick-bench.com — онлайн-бенчмарк на базе Google Benchmark. Пишешь два варианта кода, выбираешь стандарт (C++11–23) и компилятор (GCC или Clang) — и получаешь график сравнения. ❗Поддержка флагов оптимизации Можно переключать -O0, -O1, -O2, -O3 и видеть, как меняется разрыв между вариантами. Иногда «медленный» код с -O3 обходит «быстрый» без оптимизаций (Но это не точно😜). ❗ Шаринг результатов Каждый бенчмарк получает постоянную ссылку. Удобно в code review: вместо «мне кажется, так быстрее» — вот ссылка с числами. 📚 Библиотека готовых примеров На сайте есть коллекция бенчмарков от сообщества: std::string vs string_view, heap vs stack, разные контейнеры. Можно учиться на чужих измерениях. ✍️ Теперь ты сможешь поделиться своей ссылкой, чтобы доказать всем что твой код самый быстрый 🤠 📍Навигация: Вакансии • Задачи • Собесы Библиотека C/C++ разработчика #линкер_рекомендует

😎 Топ-вакансий для C++ разработчиков за неделю Developer C++ (KSMG) — Удалёнка Senior Android Security / Reverse Engineer (HTTPS Traffic, Google Services) — от 380 000 и до 500 000 ₽ Удалёнка C++ Developer (Gates Team) — от 5 000 € Офис (Дубай, Амстердам) ✍️ Еще больше топовых вакансий — в нашем канале C++ jobs 📍Навигация: Вакансии • Задачи • Собесы Библиотека C/C++ разработчика #буст

🗄️ Исходники Cfront и документы по истории C++ — теперь в открытом доступе Computer History Museum собрал архив первоисточников по C++: от ранних технических отчётов Bell Labs до исходного кода транслятора Cfront всех релизов. ❗ Cfront Release E (1985) — первый публичный релиз, по словам Страуструпа, написан им лично почти целиком. ❗Хронология стандартизации: от первого заседания ANSI J16 (1989) до принятия templates, exceptions, RTTI, namespaces и STL. ❗Оригинальные документы по operator overloading, data abstraction, coroutine-style programming — те самые идеи, которые сегодня оформились в RAII, coroutines и move semantics. ❗Три HOPL-статьи Страуструпа охватывают эволюцию языка с 1979 по 2020 год — ни один учебник не даёт такой плотности контекста😎 ✍️ Насколько современный C++ с его concepts, modules и consteval вообще узнаваем в том, что писал Страуструп в 1979-м? 📍Навигация: Вакансии • Задачи • Собесы Библиотека C/C++ разработчика #буст