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

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

🤔 Разрабатываете ИИ-агентов, но всё ещё не уверены в их стабильности и прогнозируемости? Мы поговорили с десятками разработчиков ИИ-агентов и сделали отдельный курс по 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++ разработчика #междусобойчик