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

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

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

为什么需要定制分配器？

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

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

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

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

// 简单对象池分配器模板 template class ObjectPool { private: union Node { T data; Node* next; Node() : next(nullptr) {} };

Node* free_list = nullptr;
std::vector> blocks;
Node* current_block = nullptr;

public: void* allocate() { if (!free_list) { auto& block = blocks.emplace_back(std::make_unique(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(&node->data);
}

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

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

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

};

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

使用示例：

TURF(开源)权限管理系统

TURF（开源）权限定制管理系统（以下简称“TURF系统”），是蓝水工作室推出的一套基于软件边界设计理念研发的具有可定制性的权限管理系统。TURF系统充分考虑了易用性，将配置、设定等操作进行了图形化设计，完全在web界面实现，程序员只需在所要控制的程序中简单调用一个函数，即可实现严格的程序权限管控，管控力度除可达到文件级别外，还可达到代码级别，即可精确控制到

下载

与STL容器集成

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

template class PoolAllocator { public: using value_type = T;

PoolAllocator() = default;
template PoolAllocator(const PoolAllocator&) {}

T* allocate(size_t n) {
    if (n == 1) {
        return static_cast(pool.allocate());
    }
    // 大块内存回退到默认分配
    return static_cast(::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; // 静态池，每类型一个 };