C++中如何管理动态内存分配_内存池实现方案详解

#include <iostream>

class MemoryPool {
private:
    char* pool_; // 内存池起始地址
    size_t pool_size_; // 内存池大小
    size_t block_size_; // 每个内存块的大小
    char* free_list_; // 空闲链表头

public:
    MemoryPool(size_t pool_size, size_t block_size) :
        pool_size_(pool_size),
        block_size_(block_size),
        pool_(new char[pool_size]),
        free_list_(pool_)
    {
        // 初始化空闲链表
        char* current = pool_;
        for (size_t i = 0; i < pool_size / block_size - 1; ++i) {
            *(char**)current = current + block_size;
            current += block_size;
        }
        *(char**)current = nullptr; // 链表结尾
    }

    ~MemoryPool() {
        delete[] pool_;
    }

    void* allocate() {
        if (!free_list_) {
            return nullptr; // 内存池已满
        }
        char* block = free_list_;
        free_list_ = *(char**)free_list_; // 更新空闲链表头
        return block;
    }

    void deallocate(void* block) {
        if (!block) return;

        // 将内存块重新加入空闲链表
        *(char**)block = free_list_;
        free_list_ = (char*)block;
    }
};

int main() {
    MemoryPool pool(1024, 32); // 创建一个1024字节的内存池，每个块大小为32字节

    void* block1 = pool.allocate();
    void* block2 = pool.allocate();

    if (block1 && block2) {
        std::cout << "Allocated two blocks successfully." << std::endl;
        pool.deallocate(block1);
        pool.deallocate(block2);
        std::cout << "Deallocated two blocks successfully." << std::endl;
    } else {
        std::cout << "Failed to allocate blocks." << std::endl;
    }

    return 0;
}

#include <iostream>
#include <mutex>

class ThreadSafeMemoryPool {
private:
    char* pool_;
    size_t pool_size_;
    size_t block_size_;
    char* free_list_;
    std::mutex mutex_; // 互斥锁

public:
    ThreadSafeMemoryPool(size_t pool_size, size_t block_size) :
        pool_size_(pool_size),
        block_size_(block_size),
        pool_(new char[pool_size]),
        free_list_(pool_)
    {
        char* current = pool_;
        for (size_t i = 0; i < pool_size / block_size - 1; ++i) {
            *(char**)current = current + block_size;
            current += block_size;
        }
        *(char**)current = nullptr;
    }

    ~ThreadSafeMemoryPool() {
        delete[] pool_;
    }

    void* allocate() {
        std::lock_guard<std::mutex> lock(mutex_); // 加锁
        if (!free_list_) {
            return nullptr;
        }
        char* block = free_list_;
        free_list_ = *(char**)free_list_;
        return block;
    }

    void deallocate(void* block) {
        if (!block) return;

        std::lock_guard<std::mutex> lock(mutex_); // 加锁
        *(char**)block = free_list_;
        free_list_ = (char*)block;
    }
};