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

🍒 std::generator — ленивые последовательности в стандарте

Писал итераторы с кучей boilerplate для ленивого чтения? Или тащил ranges::views для простых генераторов?

C++23 добавляет std::generator — coroutine-based ленивые последовательности. Пишешь как обычную функцию, получаешь итератор. Идеально для парсеров, ленивого чтения файлов, бесконечных последовательностей.

#include <generator>
#include <print>
#include <fstream>
#include <string>
#include <optional>

// Простой генератор чисел Фибоначчи
std::generator<uint64_t> fibonacci(size_t count) {
    uint64_t a = 0, b = 1;
    
    for (size_t i = 0; i < count; ++i) {
        co_yield a;
        auto next = a + b;
        a = b;
        b = next;
    }
}

// Ленивое чтение строк из файла
std::generator<std::string> read_lines(const std::string& filename) {
    std::ifstream file(filename);
    std::string line;
    
    while (std::getline(file, line)) {
        co_yield line;
    }
}

// Генератор простых чисел (бесконечный)
std::generator<uint64_t> primes() {
    co_yield 2;
    
    std::vector<uint64_t> found_primes;
    uint64_t candidate = 3;
    
    while (true) {
        bool is_prime = true;
        for (auto p : found_primes) {
            if (p * p > candidate) break;
            if (candidate % p == 0) {
                is_prime = false;
                break;
            }
        }
        
        if (is_prime) {
            found_primes.push_back(candidate);
            co_yield candidate;
        }
        
        candidate += 2;
    }
}

// Генератор с трансформацией
std::generator<int> squares(int n) {
    for (int i = 0; i < n; ++i) {
        co_yield i * i;
    }
}

void demo() {
    // Первые 10 чисел Фибоначчи
    std::print("Fibonacci: ");
    for (auto num : fibonacci(10)) {
        std::print("{} ", num);
    }
    std::println("");
    
    // Первые 20 простых
    std::print("Primes: ");
    size_t count = 0;
    for (auto prime : primes()) {
        std::print("{} ", prime);
        if (++count >= 20) break;
    }
    std::println("");
    
    // Квадраты
    std::print("Squares: ");
    for (auto sq : squares(5)) {
        std::print("{} ", sq);
    }
    std::println("");
}

❗️ Используй generator вместо ручного написания итераторов для ленивых последовательностей. Память выделяется только под state coroutine. Можно делать бесконечные последовательности без риска. Библиотека C/C++ разработчика #под_капотом

🐸 Подборка вакансий для C++-разработчиков за неделю Разработчик C++ — от 230 000 и до 250 000 ₽ Удалёнка Middle C++ Developer (Core) — от 200 000 ₽ Удалёнка Lead C++ Software Engineer (Gameplay) — Удалёнка С++ Tools Developer — Гибрид (Москва) Team Lead C++ — до 400 000 ₽ Удалёнка, гибрид (Москва) Разработчик С++/ QML — Офис (Москва) Библиотека C/C++ разработчика

🤖 AI сейчас на пике — и математика снова в центре внимания.

«На конференции AIJ только и разговоров, что о AI и математике. Ведь в основе генеративных моделей Gen AI лежит фундаментальная математика.»

Одна из топовых экспертов, кто сегодня участвует на AIJ, преподаёт у нас. Мария Тихонова — PhD по Computer Science, руководитель направления в SberAI и доцент ВШЭ. Она работает с LLM каждый день и объясняет математику так, как она реально применяется в AI. 🔥 Экспресс-курс «Математика для DS» — 8 недель, чтобы закрыть пробелы и уверенно проходить собесы. 🎁 До 30 ноября: → скидка 40% → курс «Школьная математика» в подарок при оплате → бесплатный тест на знание основ математики 👉 Записаться на курс

🍕 include-what-you-use — очистка include директив

Ваш файл включает половину стандартной библиотеки, а использует только std::vector?

IWYU (include-what-you-use) — инструмент от Google, который анализирует какие заголовочные файлы реально используются и предлагает минимальный набор includes. Ускоряет компиляцию и делает зависимости явными. 🍴 Установка:

# Ubuntu
sudo apt install iwyu

# Из исходников с нужной версией clang
git clone https://github.com/include-what-you-use/include-what-you-use.git

✏️ Использование:

# Анализ файла
include-what-you-use main.cpp

# С применением исправлений
include-what-you-use main.cpp 2>&1 | fix_includes.py

# Для всего CMake проекта
cmake -DCMAKE_CXX_INCLUDE_WHAT_YOU_USE=include-what-you-use ..

❗️ Основные проблемы, которые находит: • Лишние includes — файлы, которые не используются • Транзитивные includes — зависимости через другие заголовки • Forward declarations — где можно заменить include на forward decl • Неполные includes — когда используется тип, но не включён его заголовок ✏️ Github Библиотека C/C++ разработчика #под_капотом

😵‍💫 Усиль свои позиции на собесе в Data Science знаниями математики! Чем важна математика расскажет Мария Тихонова - кандидат компьютерных наук, руководитель исследовательского направления SberAI, доцент факультета компьютерных наук и преподаватель НИУ ВШЭ на курсе «Математика для Data Science» от Proglib Academy. 👀 Мария - человек, который реально работает с LLM и делает так, чтобы модели понимали человеческую речь, а не делали вид. 📌 Добавь в свое портфолио проект, выделись среди конкурентов Курс предусматривает выполнение практического проекта с фидбеком от экспертов. За проект можно взять темы: • обучите градиентный спуск для предсказания цен на квартиры • создадите классификатор тональности или тематики текста • построите простую рекомендательную систему на матричных разложениях Бонусы: - скидка 40% до 30 ноября - если оплатить до конца ноября, получите курс «Базовая математика» в подарок ➡️ Пройти бесплатный тест на знание математики 👇👇👇 Записаться на курс

🍴 Что происходит при копировании std::array? Казалось бы, простой вопрос. Но копирование array работает совсем не так, как у vector. Проблема: в C++ массивы не копируются обычным =. Но std::array копируется. Как? ⚡️ Ключевое отличие: std::array — это агрегатный тип, а агрегаты копируются поэлементно.

std::array<int, 3> a = {1, 2, 3};
std::array<int, 3> b = a;  // Копируются ВСЕ элементы!

Под капотом компилятор генерирует:

b._data[0] = a._data[0];
b._data[1] = a._data[1];
b._data[2] = a._data[2];

❗️ Важно: это происходит на этапе компиляции. Для array<int, 1000> будет сгенерировано 1000 операций присваивания. Или одна memcpy, если компилятор умный. ❌ Ловушка: копирование большого array может быть дорогим. В отличие от vector (копируется только указатель при move), array всегда копирует данные целиком. Практический вывод: передавайте большие array по ссылке (const std::array<T, N>&), иначе каждый вызов функции скопирует все N элементов. Библиотека C/C++ разработчика #под_капотом

Мы? 🐸 Библиотека программиста

🎓 Экспресс-курс «Математика для Data Science» стартует 4 декабря Этот курс для вас, если вы: 🧑‍💻 Программист Когда нужно понять, что происходит «под капотом» ML-алгоритмов. 📊 Начинающий DS / аналитик / студент Чтобы закрыть теорию, подтянуть фундамент и собрать портфолио. 📈 Смежный специалист Чтобы уверенно работать с моделями, статистикой и гипотезами. 🎁 Сейчас лучший момент стартовать: — скидка 40% на курс до конца ноября — можно пройти бесплатный тест на знание основ математики 👉 Записаться на курс

🔥 std::flat_map в C++23 — быстрее std::map в 3-5 раз?

Представьте: вы профилируете код и видите, что std::map тормозит. Cache misses, фрагментация памяти, медленный поиск.

C++23 представляет std::flat_map и std::flat_set — адаптеры контейнеров, которые хранят элементы в непрерывной памяти. Вместо узлов дерева — два плоских массива (ключи + значения).

#include <flat_map>

std::flat_map<int, std::string> cache{
    {1, "one"}, {2, "two"}, {3, "three"}
};

// Все элементы рядом в памяти — процессор доволен
auto it = cache.find(2); // Бинарный поиск по упорядоченному массиву

❗️ Главные преимущества: • Меньше cache misses → быстрее на реальных данных • Меньше аллокаций памяти • Лучше для read-heavy сценариев ✏️ Когда использовать? Если у вас много поисков и мало изменений — flat_map будет более производительным чем классический map. Библиотека C/C++ разработчика #константная_правильность

🍿 Лямбды в STL: где они сияют STL-алгоритмы — основное применение лямбд в C++. Они превратили императивные циклы в декларативные выражения, делающие код выразительнее и безопаснее. Классика — std::transform:

std::transform(vec.begin(), vec.end(), vec.begin(), [](int x) { return x * 2; });

умножает все элементы на два. Или std::sort с кастомным компаратором:

std::sort(vec.begin(), vec.end(), [](const auto& a, const auto& b) { return a.priority > b.priority; });

Предикатные алгоритмы особенно элегантны:

std::count_if, std::find_if, std::remove_if

Вместо циклов с условиями — одна строка:

auto count = std::count_if(vec.begin(), vec.end(), [](int x) { return x > 0; });

Логика фильтрации инкапсулирована и переиспользуема. C++20 ranges делают это ещё лучше:

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

— цепочка трансформаций без промежуточных контейнеров. Лямбды с алгоритмами — это функциональное программирование в C++. Код становится декларативным, меньше ручного управления итераторами, меньше ошибок off-by-one. Оптимизатор видит больше возможностей для векторизации. Как часто вы заменяете циклы на STL-алгоритмы с лямбдами? Библиотека C/C++ разработчика #междусобойчик

🚀 В IT ценится не перфекционизм, а движение вперёд, и если вы давно откладывали обучение — самое время начать. ❤️ Proglib Academy продлевает розыгрыш MacBook Pro 14 до 30 ноября! Что нужно: ⚡️ выбрать курс; ⚡️ пройти минимум две недели обучения (можно за два вечера); ⚡️ написать куратору #розыгрыш; ⚡️ забрать макбук. 🎓 Курсы, которые участвуют 👉 Участвовать

🍴 Callback chain (цепочка обработчиков)

Надоело писать if-else лесенки для обработки событий? Лямбды превращают это в изящную цепочку.

Паттерн Chain of Responsibility через лямбды позволяет регистрировать обработчики, которые выполняются последовательно, пока кто-то не обработает событие:

#include <vector>
#include <functional>
#include <algorithm>

template<typename Event>
class CallbackChain {
    using Handler = std::function<bool(const Event&)>;
    std::vector<Handler> handlers_;

public:
    // Добавить обработчик в конец цепочки
    void add_handler(Handler handler) {
        handlers_.push_back(std::move(handler));
    }
    
    // Добавить обработчик в начало (высокий приоритет)
    void add_handler_front(Handler handler) {
        handlers_.insert(handlers_.begin(), std::move(handler));
    }
    
    // Обработать событие (возвращает true, если кто-то обработал)
    bool handle(const Event& event) const {
        for (const auto& handler : handlers_) {
            if (handler(event)) {
                return true;  // Обработчик вернул true - останавливаемся
            }
        }
        return false;  // Никто не обработал
    }
    
    // Уведомить всех обработчиков (не останавливаясь)
    void notify_all(const Event& event) const {
        for (const auto& handler : handlers_) {
            handler(event);  // Игнорируем возвращаемое значение
        }
    }
    
    // Очистить все обработчики
    void clear() { handlers_.clear(); }
    
    size_t size() const { return handlers_.size(); }
};

Использование для обработки HTTP-запросов:

struct HttpRequest {
    std::string path;
    std::string method;
    std::map<std::string, std::string> params;
};

CallbackChain<HttpRequest> router;

// Регистрируем обработчики
router.add_handler([](const HttpRequest& req) {
    if (req.path == "/api/users" && req.method == "GET") {
        handle_get_users();
        return true;  // Обработали
    }
    return false;  // Не наш запрос
});

router.add_handler([](const HttpRequest& req) {
    if (req.path.starts_with("/api/")) {
        return handle_api_request(req);
    }
    return false;
});

// В главном цикле
void process_request(const HttpRequest& req) {
    if (!router.handle(req)) {
        send_404_error();
    }
}

Библиотека C/C++ разработчика #шаблонный_код

🍴 XTML: минималистичный C++‑движок для HTML‑шаблонов XTML — утилита написанная на C++, предназначенная для обработки шаблонных файлов и генерации динамического HTML. 💡 Ключевые фичи: • Переменные и плейсхолдеры: определяйте переменные и вставляйте их через {{@varName}} • Условная логика и циклы: поддерживаются if, else, while для динамической генерации • Вычисление выражений: математика, строковые операции, работа с массивами • Функции и модули: определяйте функции в шаблонах или расширяйте через C++ DLL HTML в выражениях: можно генерировать HTML прямо из вычисляемых выражений ❗️Пример: Шаблон:

<xtml>
    var title = "XTML Example Page";
    var a = 15;
    var b = 7;
    var comparison = expr {
        if (a > b) { 
            print("a is greater than b"); 
        } 
        else { 
            print("a is not greater than b"); 
        }
    };
</xtml>

<html>
<head>
    <title>{{@title}}</title>
</head>
<body>
    <p>{{@comparison}}</p>
</body>
</html>

Сборка и вывод:

xtml build template.xtml

<html>
<head>
    <title>XTML Example Page</title>
</head>
<body>
    <p>a is greater than b</p>
</body>
</html>

✏️ Github Библиотека C/C++ разработчика #буст

🏢➰ Булевый поиск: как находить «спрятанные» вакансии в LinkedIn, GitHub и Google В этой статье мы расскажем, как с помощью булевого поиска можно искать вакансии на LinkedIn и hh.ru (обходя кривые фильтры); на GitHub, где компании и эйчары выкладывают позиции в репозиториях и issues; а также через Google, находя карьерные страницы компаний, которые плохо индексируются. Библиотека C/C++ разработчика #буст