🦀 Транспиляция кода: от одного языка к другому

Представьте ситуацию: вы нашли идеальное решение на GitHub, но оно написано не на том языке. Или ваш руководитель прочитал статью о новом фреймворке, и теперь нужно переписывать всю кодовую базу. Знакомо?

Хорошая новость: современные LLM-модели отлично справляются с транспиляцией кода между языками программирования.


✏️ Промпт

Rewrite the following code in C++:

[Вставь свой код сюда]

🍴 Пример использования

# Исходный Python код

def count_words(text):
    """Count word frequency in text"""
    words = text.lower().split()
    freq = {}
    for word in words:
        freq[word] = freq.get(word, 0) + 1
    return freq

# Пример использования
text = "hello world hello python world"
print(count_words(text))
# Output: {'hello': 2, 'world': 2, 'python': 1}

Результат:

#include <iostream>
#include <string>
#include <map>
#include <sstream>
#include <algorithm>

std::map<std::string, int> count_words(const std::string& text) {
    std::map<std::string, int> freq;
    std::istringstream stream(text);
    std::string word;
    
    while (stream >> word) {
        // Convert to lowercase
        std::transform(word.begin(), word.end(), word.begin(), ::tolower);
        freq[word]++;
    }
    
    return freq;
}

int main() {
    std::string text = "hello world hello python world";
    auto result = count_words(text);
    
    for (const auto& [word, count] : result) {
        std::cout << word << ": " << count << std::endl;
    }
    
    return 0;
}

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

#буст

🍬 Потоки могут общаться через condition_variable

Чтобы один поток ожидал другого можно воспользоваться condition_variable.


🍴 Пошаговое решение:

1️⃣ Создайте condition_variable и mutex
2️⃣ Поток ждёт через wait()
3️⃣ Другой поток сигналит через notify_one/notify_all

#include <condition_variable>
#include <mutex>
#include <thread>
#include <iostream>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void worker() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; }); // Ждём сигнала
    
    std::cout << "Worker started!\n";
}

int main() {
    std::thread t(worker);
    
    std::this_thread::sleep_for(std::chrono::seconds(1));
    
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_one(); // Будим поток
    
    t.join();
    return 0;
}

❗️ Частая ошибка: Забыть проверять условие в wait()

💡 Совет: Всегда передавайте предикат в wait()


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

#буст

💡 C++: Генерация шаблонного кода

Запуск нового C++ проекта часто начинается с рутины: создание классов с конструкторами, деструкторами, операторами копирования/перемещения, шаблоны паттернов... Звучит очень знакомо и ужасно скучно. Что хотябы немного облегчить себе задачу можно воспользоваться AI.

Хотя AI и не знает бизнес-логику проекта, но зато он отлично справляется с созданием базовой структуры проекта.


✏️ Пример использования


Промпт:

Создай boilerplate код для C++ класса ResourceManager, 
который управляет игровыми ресурсами (текстуры, звуки). 
Класс должен быть синглтоном, 
шаблонными методами загрузки/получения ресурсов и 
thread-safe доступом.

Результат:

#pragma once
#include <memory>
#include <unordered_map>
#include <mutex>
#include <string>

template<typename T>
class ResourceManager {
private:
    std::unordered_map<std::string, std::shared_ptr<T>> resources;
    mutable std::mutex mutex;
    
    // Приватный конструктор для синглтона
    ResourceManager() = default;
    
public:
    // Удаляем конструктор копирования и оператор присваивания
    ResourceManager(const ResourceManager&) = delete;
    ResourceManager& operator=(const ResourceManager&) = delete;
    
    // Конструктор и оператор перемещения
    ResourceManager(ResourceManager&&) noexcept = default;
    ResourceManager& operator=(ResourceManager&&) noexcept = default;
    
    // Деструктор
    ~ResourceManager() = default;
    
    // Получение единственного экземпляра (Meyer's Singleton)
    static ResourceManager& getInstance() {
        static ResourceManager instance;
        return instance;
    }
    
    // Загрузка ресурса
    template<typename... Args>
    bool load(const std::string& id, Args&&... args) {
        std::lock_guard<std::mutex> lock(mutex);
        
        if (resources.find(id) != resources.end()) {
            return false; // Уже загружен
        }
        
        auto resource = std::make_shared<T>(std::forward<Args>(args)...);
        resources[id] = resource;
        return true;
    }
    
    // Получение ресурса
    std::shared_ptr<T> get(const std::string& id) const {
        std::lock_guard<std::mutex> lock(mutex);
        
        auto it = resources.find(id);
        return (it != resources.end()) ? it->second : nullptr;
    }
    
    // Выгрузка ресурса
    bool unload(const std::string& id) {
        std::lock_guard<std::mutex> lock(mutex);
        return resources.erase(id) > 0;
    }
    
    // Очистка всех ресурсов
    void clear() {
        std::lock_guard<std::mutex> lock(mutex);
        resources.clear();
    }
};

🍿 Что получили?

• Полностью рабочий шаблонный класс
• Thread-safe операции

Теперь можешь сразу добавлять свою бизнес-логику, вместо того чтобы тратить время на шаблонный код🙂

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

#буст

🎫 std::latch — одноразовый счетчик


🩹 Проблема:

Главный поток должен дождаться завершения инициализации в нескольких рабочих потоках перед началом основной работы. Барьер не подходит, так как нужна одноразовая синхронизация, а не переиспользуемая.


💡 Решение:

std::latch (C++20) — это одноразовый счетчик обратного отсчета. Потоки уменьшают счетчик, а другие ждут, пока он достигнет нуля. После срабатывания latch нельзя переиспользовать.


✏️ Пример кода:

#include <iostream>
#include <thread>
#include <latch>
#include <vector>

void worker_init(int id, std::latch& ready_signal) {
    // Имитация инициализации ресурсов
    std::cout << "Поток " << id << " инициализируется...\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(100 * id));
    
    std::cout << "Поток " << id << " готов\n";
    ready_signal.count_down();  // Уменьшаем счетчик
}

void worker_process(int id, std::latch& start_signal) {
    std::cout << "Поток " << id << " ждет сигнал старта...\n";
    start_signal.wait();  // Ждем пока счетчик станет 0
    
    std::cout << "Поток " << id << " начал обработку\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
}

int main() {
    const int num_workers = 4;
    std::latch all_ready(num_workers);  // Счетчик для готовности
    std::latch start_work(1);  // Сигнал для старта
    
    std::vector<std::thread> threads;
    
    // Создаем рабочие потоки
    for (int i = 0; i < num_workers; ++i) {
        threads.emplace_back([i, &all_ready, &start_work]() {
            worker_init(i, all_ready);
            worker_process(i, start_work);
        });
    }
    
    // Главный поток ждет готовности всех
    std::cout << "Главный поток ждет инициализации...\n";
    all_ready.wait();
    
    std::cout << "Все потоки готовы. Даем сигнал старта!\n";
    start_work.count_down();  // Даем сигнал старта
    
    for (auto& t : threads) {
        t.join();
    }
    
    return 0;
}

‼️ Преимущества:

• Простая одноразовая синхронизация множества потоков
• Эффективное ожидание без активных проверок
• Идеален для сценариев типа ждать «готовности всех»
• Минимальные накладные расходы по сравнению с condition_variable


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

#буст

🍿 std::partition — Разделение данных по условию

🔥 Проблема:

Разработчикам часто нужно разделить коллекцию на две группы: элементы, удовлетворяющие условию, и остальные. Ручная реализация требует дополнительных контейнеров или сложной логики с несколькими проходами по данным.


💡Решение:

Алгоритм std::partition переупорядочивает элементы так, что все удовлетворяющие предикату оказываются в начале. Возвращает итератор на границу разделения.


✏️ Пример кода:

#include <algorithm>
#include <vector>

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

// Разделяем на четные и нечетные
auto boundary = std::partition(numbers.begin(), numbers.end(),
    [](int n) { 
        return n % 2 == 0; // Четные в начало
    }
);

// Теперь numbers = {6, 4, 2, 8, 3, 9, 5, 7, 1}
// boundary указывает на первый нечетный элемент

// Обрабатываем только четные числа
for (auto it = numbers.begin(); it != boundary; ++it) {
    *it *= 2; // Удваиваем четные
}

🍨 Преимущества:

• Эффективность: работает in-place без дополнительной памяти O(1)
• Скорость: линейная сложность O(n) за один проход
• Стабильность: существует std::stable_partition для сохранения порядка
• Универсальность: подходит для любых типов данных с произвольным предикатом


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

#буст

✏️ Потокобезопасная инициализация через std::call_once

Инициализация ресурсов в многопоточном приложении — классическая головная боль. std::call_once решает эту проблему элегантно: гарантирует вызов функции ровно один раз, даже если несколько потоков пытаются сделать это одновременно. Забудьте про ручные мьютексы и double-checked locking с их подводными камнями.

#include <mutex>
#include <memory>
#include <iostream>

class DatabaseConnection {
public:
    static DatabaseConnection& getInstance() {
        // std::call_once гарантирует однократный вызов лямбды
        // даже при конкурентном доступе из разных потоков
        std::call_once(initFlag, []() {
            instance.reset(new DatabaseConnection());
            std::cout << "Database initialized\n";
        });
        return *instance;
    }

    void query(const std::string& sql) {
        std::cout << "Executing: " << sql << "\n";
    }

    // Запрещаем копирование и перемещение
    DatabaseConnection(const DatabaseConnection&) = delete;
    DatabaseConnection& operator=(const DatabaseConnection&) = delete;

private:
    DatabaseConnection() {
        // Тяжелая инициализация: подключение к БД,
        // загрузка конфигурации и т.д.
    }

    static std::once_flag initFlag;        // Флаг для call_once
    static std::unique_ptr<DatabaseConnection> instance;
};

// Определение статических членов
std::once_flag DatabaseConnection::initFlag;
std::unique_ptr<DatabaseConnection> DatabaseConnection::instance;

‼️ Ключевые особенности:

✅ Потокобезопасность из коробки — не нужен ручной mutex, std::call_once сам блокирует конкурентные вызовы
✅ Без накладных расходов после первого вызова — последующие вызовы проверяют только атомарный флаг
✅ Исключения не ломают логику — если инициализация бросила exception, флаг не устанавливается и следующий поток попробует снова
✅ Работает с любыми callable — лямбды, функции, функторы, std::bind


Используете std::call_once в продакшене? Какие кейсы у вас?

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

#буст

🍴 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++ разработчика

#шаблонный_код

🔥 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++ разработчика

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

🍒 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++ разработчика

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