Универсальный язык программирования

#include <cstdlib>
#include <iostream>
 
class SimpleResourceManager {
private:
    struct Resource {
        void* header;
        void (*deleter)(void*);
    };
    
    Resource* resources;
    int count;
    int capacity;
 
public:
    // Конструктор
    SimpleResourceManager() : resources(nullptr), count(0), capacity(0) {}
    
    // Конструктор с одним ресурсом
    SimpleResourceManager(void* header, void (*deleter)(void*)) 
        : resources(nullptr), count(0), capacity(0) {
        addResource(header, deleter);
    }
    
    // Добавление ресурса
    void addResource(void* header, void (*deleter)(void*)) {
        if (!header || !deleter) return;
        
        // Увеличиваем емкость при необходимости с помощью realloc
        if (count >= capacity) {
            int newCapacity = capacity == 0 ? 4 : capacity * 2;
            
            // Используем realloc для изменения размера массива
            Resource* newResources = static_cast<Resource*>(
                std::realloc(resources, newCapacity * sizeof(Resource))
            );
            
            if (!newResources) {
                // Ошибка выделения памяти
                std::cerr << "Memory allocation failed in addResource\n";
                return;
            }
            
            resources = newResources;
            capacity = newCapacity;
        }
        
        // Добавляем новый ресурс
        resources[count].header = header;
        resources[count].deleter = deleter;
        count++;
    }
    
    // Удаление ресурса по индексу (освобождает и удаляет из массива)
    void removeResource(int index) {
        if (index < 0 || index >= count) return;
        
        // Освобождаем ресурс
        if (resources[index].header && resources[index].deleter) {
            resources[index].deleter(resources[index].header);
        }
        
        // Сдвигаем остальные элементы
        for (int i = index; i < count - 1; i++) {
            resources[i] = resources[i + 1];
        }
        
        count--;
    }
    
    // Освобождение всех ресурсов
    void releaseAll() {
        for (int i = 0; i < count; i++) {
            if (resources[i].header && resources[i].deleter) {
                resources[i].deleter(resources[i].header);
            }
        }
        count = 0;
    }
    
    // Освобождение всех ресурсов и освобождение памяти массива
    void clear() {
        releaseAll();
        std::free(resources);
        resources = nullptr;
        capacity = 0;
    }
    
    // Получение количества ресурсов
    int getResourceCount() const {
        return count;
    }
    
    // Получение текущей емкости
    int getCapacity() const {
        return capacity;
    }
    
    // Получение ресурса по индексу (без передачи владения)
    void* getResource(int index) const {
        if (index < 0 || index >= count) return nullptr;
        return resources[index].header;
    }
    
    // Получение функции освобождения по индексу
    void (*getDeleter(int index))(void*) {
        if (index < 0 || index >= count) return nullptr;
        return resources[index].deleter;
    }
    
    // Деструктор
    ~SimpleResourceManager() {
        releaseAll();
        std::free(resources);
    }
    
    // Запрещаем копирование (для простоты)
    SimpleResourceManager(const SimpleResourceManager&) = delete;
    SimpleResourceManager& operator=(const SimpleResourceManager&) = delete;
    
    // Перемещающий конструктор
    SimpleResourceManager(SimpleResourceManager&& other) noexcept 
        : resources(other.resources), count(other.count), capacity(other.capacity) {
        other.resources = nullptr;
        other.count = 0;
        other.capacity = 0;
    }
    
    // Перемещающий оператор присваивания
    SimpleResourceManager& operator=(SimpleResourceManager&& other) noexcept {
        if (this != &other) {
            // Освобождаем текущие ресурсы
            releaseAll();
            std::free(resources);
            
            // Перемещаем из other
            resources = other.resources;
            count = other.count;
            capacity = other.capacity;
            
            // Обнуляем other
            other.resources = nullptr;
            other.count = 0;
            other.capacity = 0;
        }
        return *this;
    }
};

#include <iostream>
 
// Пример функций освобождения
void freeIntArray(void* ptr) {
    int* arr = static_cast<int*>(ptr);
    delete[] arr;
    std::cout << "Freed int array of size 100\n";
}
 
void freeString(void* ptr) {
    char* str = static_cast<char*>(ptr);
    delete[] str;
    std::cout << "Freed string\n";
}
 
int main() {
    // Создаем менеджер
    SimpleResourceManager manager;
    
    // Добавляем несколько ресурсов
    int* data1 = new int[100];
    manager.addResource(data1, freeIntArray);
    
    char* text = new char[50];
    manager.addResource(text, freeString);
    
    std::cout << "Resources count: " << manager.getResourceCount() << "\n";
    std::cout << "Current capacity: " << manager.getCapacity() << "\n";
    
    // Добавляем еще больше ресурсов для проверки realloc
    for (int i = 0; i < 10; i++) {
        int* value = new int(i);
        manager.addResource(value, [](void* p) {
            delete static_cast<int*>(p);
        });
    }
    
    std::cout << "After adding 10 more resources:\n";
    std::cout << "Resources count: " << manager.getResourceCount() << "\n";
    std::cout << "Current capacity: " << manager.getCapacity() << "\n";
    
    // Удаляем ресурс по индексу 1 (текст)
    std::cout << "\nRemoving resource at index 1:\n";
    manager.removeResource(1);
    std::cout << "Resources count after removal: " << manager.getResourceCount() << "\n";
    
    // // Получаем ресурс по индексу
    // void* resource = manager.getResource(0);
    // std::cout << "Resource at index 0: " << resource << "\n";
    
    // Очищаем все вручную
    // manager.clear();
    
    // При выходе из области видимости деструктор освободит все оставшиеся ресурсы
    return 0;
}