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

🏃‍♀️ Уже завтра стартует курс по разработке AI-агентов. Про AI-агентов часто думают, что это просто модная обертка над джпт для пет-проектов. Кажется, прикрутил API к скрипту и типа готово. А вот и нет! Когда дело доходит до прода, начинаются настоящие проблемы.

Зачем глубоко копать мультиагентные системы, если можно обойтись старым добрым кодом? Как контролировать расходы на токены, чтобы новая фича не разорила бизнес? Как заставить агента работать стабильно и предсказуемо, а не галлюцинировать?

Эту инженерную часть мы и будем разбирать на курсе. Будем учиться интегрировать внешние API, работать с RAG, LangGraph, CrewAI и деплоить всё это так, чтобы работало как часы. Стартуем завтра. Для участия и доступа к программе переходите по ссылке.

📰 Свеженькое из мира C++ Подготовили подборку самых интересных материалов за неделю о разных аспектах программирования и интересных проектах в мире C++. 😎 Интересное: • Как техлиду перестать быть справочником и научить своих аналитиков самостоятельности — разбор как лиду работать, а не работать поисковиком • Почему constexpr вычисляется не всегда в compile-time — особенности работы constexpr в реальных проектах • C++ Ranges. Ленивые вычисления (C++20) — продолжаем тему диапазонов • std::call_once и once_flag: явная ленивая инициализация — фитча, помогающая удобно подгружать ресурсы • Как использовать ИИ для составления резюме и поиска работы: 5 рабочих промптов — советы, как с помощью AI продвинуть свой резюме 🔹📍Навигация: Вакансии • Задачи • Собесы Библиотека C/C++ разработчика #свежак

🦾 Надоело чинить «упавших» ИИ-агентов после каждого микросбоя внешних сервисов? Анонсируем старт продаж большого курса по AgentOps. Мы собрали опыт десятков разработчиков и сделали программу, которая учит выводить ИИ в стабильный прод. 🗓 Ждем вас 28 апреля в 19:00 МСК на эфире: «Как эффективно управлять контекстным окном LLM в мультиагентных системах и не сливать бюджет на токены». 👉 Кто вещает и в чем польза? Спикер Кирилл Кухарев (Senior AI Engineer в Raft, спикер AI Conf и Highload++). Он реализовал более 50 коммерческих проектов в GenAI и на вебинаре покажет, как взять под контроль работу нескольких агентов, чтобы они не перекидывали друг другу лишний контекст и не сжигали ваши деньги. В прямом эфире разберем: • Как формируется контекст в LLM при маршрутизации между агентами; • Куда утекают лишние токены и возникает перерасход; • Практические методы: как сжимать историю, грамотно делить задачи, лимитировать передачу контекста и собирать промпты прямо в процессе запроса пользователя. 🔥 Два способа получить максимум: 1. Приходите на вебинар 28 апреля. Дарим участникам промокод на 5.000 ₽ (работает 3 дня после эфира - это шанс забрать курс по самому низу рынка). 2. Выбирайте Инженерный трек. В подарок к нему идет полный доступ к записям и автопроверкам завершенного курса «Разработка ИИ-агентов». 👉 Занять место на вебинаре и стать профи в AgentOps

🚀 Челендж на выходных: полный ленивый pipeline Собери всё вместе: напиши ленивый pipeline обработки данных без лишних копий и временных контейнеров.

// Дано: файл с числами (по одному на строку)
// Задача: найти сумму квадратов чётных чисел из первых 1000 строк

// Наивное решение (неленивое):
// 1. Загрузить всё в vector<int>          — O(n) память
// 2. Отфильтровать чётные                 — ещё O(n)
// 3. Возвести в квадрат                   — ещё O(n)
// 4. Просуммировать первые 1000           — O(n)

// Ленивое решение должно:
// - Читать файл построчно (не грузить всё)
// - Фильтровать на лету
// - Трансформировать на лету
// - Останавливаться после 1000 элементов

// Скелет:
auto result = lines_from_file("data.txt")       // ленивый итератор строк
    | parse_ints()                              // string -> optional<int>
    | filter_valid()                            // убрать nullopt
    | filter([](int x){ return x % 2 == 0; })  // только чётные
    | transform([](int x){ return x * x; })    // квадрат
    | take(1000)                                // первые 1000
    | sum();                                    // свёртка

// TODO: реализуй каждый адаптер в цепочке

✏️ Задача: реализуй весь pipeline. Можно использовать C++20 Ranges или написать адаптеры вручную. Ключевое требование — в любой момент в памяти хранится не более одного элемента из файла. 📍Навигация: Вакансии • Задачи • Собесы Библиотека C/C++ разработчика #междусобойчик

🤖 Ваш ИИ-агент съедает бюджет на токены и падает при сбоях API? Пора переходить на новый уровень. Открыли продажи курса по AgentOps — управлению ИИ-агентами в рабочих процессах. Рынок требует инженеров, которые умеют: • Контролировать метрики и качество ответов; • Эффективно работать с RAG-архитектурой; • Строить системы, готовые к реальным нагрузкам. Обучение займет 6-12 недель под руководством практиков с опытом в AI и Data Science в крупных IT-компаниях, таких как Яндекс, Сбер, МТС, Huawei, Raft и др. 🎁 Можно подождать, пока про AgentOps начнут говорить все. Или зайти сейчас — НА 30% ДЕШЕВЛЕ!

Работа с AI начинается с систем. Системы — с AgentOps.

🔥 Забрать скидку и изучить программу.

🤖📝 Как использовать ИИ для составления резюме и поиска работы: 5 рабочих промптов Попросить нейросеть «улучшить текст» — это не стратегия, это косметика. Настоящая сила LLM заключается в анализе сотен вакансий, профилей конкурентов и данных о компании. Вот 5 промптов, которые реально работают. 👉 Статья 📍Навигация: Вакансии • Задачи • Собесы Библиотека C/C++ разработчика #буст

📍Навигация: Вакансии • Задачи • Собесы Библиотека 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 и библиотеками оркестрации; — готовые паттерны для обработки ошибок и галлюцинаций; — опыт создания систем, которые реально экономят время. Есть пара мест со скидкой до завтра, решайтесь 👈🏻