C++内存分配优化定制分配器实现-C++-PHP中文网

C++内存分配优化定制分配器实现

P粉602998670

发布： 2025-08-20 12:15:01

原创

210人浏览过

定制分配器通过预分配内存池和自由链表管理，减少系统调用与碎片，提升高频小对象分配效率，适用于游戏引擎等性能敏感场景。

c++内存分配优化定制分配器实现

在C++中，频繁的动态内存分配和释放（尤其是小对象）会带来性能开销，主要来自堆管理的碎片化和系统调用的延迟。通过定制内存分配器，可以显著提升程序性能，特别是在高频率分配/释放场景下，比如游戏引擎、实时系统或高频交易系统。

为什么需要定制分配器？

标准库的 new 和 malloc 是通用方案，适合大多数场景，但不够高效。它们每次分配都可能涉及系统调用、锁竞争（多线程）、内存对齐处理和碎片管理。定制分配器通过以下方式优化：

预分配大块内存，减少系统调用次数
针对特定对象大小做内存池化（如固定大小分配器）
减少内存碎片，提升缓存局部性
支持对象重用，避免重复构造/析构

实现一个简单的对象池分配器

适用于固定大小对象（如Node、Packet等）的高频分配。核心思路是预先分配一组对象，用自由链表管理空闲项。

// 简单对象池分配器模板 template<typename T, size_t BlockSize = 1024> class ObjectPool { private: union Node { T data; Node* next; Node() : next(nullptr) {} };

Node* free_list = nullptr;
std::vector<std::unique_ptr<Node[]>> blocks;
Node* current_block = nullptr;

登录后复制

public: void* allocate() { if (!free_list) { auto& block = blocks.emplace_back(std::make_unique<Node[]>(BlockSize)); current_block = block.get();

        // 链接块内所有节点
        for (size_t i = 0; i < BlockSize - 1; ++i) {
            block[i].next = &block[i + 1];
        }
        block[BlockSize - 1].next = nullptr;
        free_list = current_block;
    }

    Node* node = free_list;
    free_list = free_list->next;
    return static_cast<void*>(&node->data);
}

void deallocate(void* ptr) {
    if (ptr) {
        Node* node = reinterpret_cast<Node*>(ptr);
        node->next = free_list;
        free_list = node;
    }
}

template<typename... Args>
T* construct(Args&&... args) {
    void* mem = allocate();
    return new (mem) T(std::forward<Args>(args)...);
}

void destroy(T* ptr) {
    if (ptr) {
        ptr->~T();
        deallocate(ptr);
    }
}

登录后复制

};

立即学习“C++免费学习笔记（深入）”；

使用示例：

琅琅配音

全能AI配音神器

208

查看详情

struct Point { float x, y; Point(float x, float y) : x(x), y(y) {} };

ObjectPool pool; Point* p1 = pool.construct(1.0f, 2.0f); pool.destroy(p1);

与STL容器集成

可以通过自定义分配器适配STL容器。分配器需实现 allocate、deallocate，并满足分配器概念。

template class PoolAllocator { public: using value_type = T;

PoolAllocator() = default;
template<typename U> PoolAllocator(const PoolAllocator<U>&) {}

T* allocate(size_t n) {
    if (n == 1) {
        return static_cast<T*>(pool.allocate());
    }
    // 大块内存回退到默认分配
    return static_cast<T*>(::operator new(n * sizeof(T)));
}

void deallocate(T* ptr, size_t n) {
    if (n == 1) {
        pool.deallocate(ptr);
    } else {
        ::operator delete(ptr);
    }
}

登录后复制

private: inline static ObjectPool pool; // 静态池，每类型一个 };

用于STL容器：

std::vector> vec; vec.emplace_back(1.0f, 2.0f); // 使用池分配