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;
}

#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;
}

std::lock_guard lock1(mtx1);
std::lock_guard lock2(mtx2); // deadlock риск!

std::scoped_lock lock(mtx1, mtx2); // безопасно

Создай 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();
    }
};

#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;
}

uint32_t swap(uint32_t x) {
    return ((x >> 24) & 0xff) | ((x << 8) & 0xff0000) |
           ((x >> 8) & 0xff00) | ((x << 24) & 0xff000000);
}

uint32_t swapped = std::byteswap(value);