【C/C++】深度解析C++ Allocator：优化内存管理的关键

CodeWithMe

于 2025-05-15 18:26:11 发布

阅读量502

点赞数 23

分类专栏： C/C++ 文章标签： c++

本文链接：https://blog.csdn.net/YZJincsdn/article/details/147985886

版权

C/C++ 专栏收录该内容

109 篇文章

订阅专栏

文章目录

深度解析C++ Allocator：优化内存管理的关键

深度解析C++ Allocator：优化内存管理的关键

Allocator 是用于控制内存分配和释放的底层机制，尤其在 STL 容器（如 vector、map）中至关重要。

c++允许开发者自定义内存管理策略，在不修改容器逻辑的前提下，优化内存使用效率或适配复杂场景, 从而优化性能或适配特殊场景（如共享内存、内存池）。

1 默认 `std::allocator`

STL 容器默认使用 std::allocator，它直接调用 new 和 delete 进行内存管理：

#include <vector>
#include <memory>

std::vector<int, std::allocator<int>> vec;  // 显式指定默认分配器（通常省略）

2 自定义 Allocator

使用自定义分配器的常见场景：

内存池：预分配大块内存，避免频繁调用 new/delete。
对齐控制：确保内存按特定对齐方式分配（如 SIMD 指令要求）。
共享内存：在进程间共享内存（需配合操作系统 API）。
调试跟踪：统计内存分配次数或检测内存泄漏。
持久化存储：将对象分配到非易失性内存（如硬盘映射内存）。

3 自定义 Allocator 的实现

3.1 基本结构

#include <cstdlib>
#include <memory>

template <typename T>
class CustomAllocator {
public:
    // 类型定义（必须）
    using value_type = T;
    using pointer = T*;
    using const_pointer = const T*;
    using reference = T&;
    using const_reference = const T&;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;

    // C++11 后需要定义 propagate_on_container_* 特性
    using propagate_on_container_copy_assignment = std::true_type;
    using propagate_on_container_move_assignment = std::true_type;
    using propagate_on_container_swap = std::true_type;

    // 构造与析构（通常为默认）
    CustomAllocator() = default;
    ~CustomAllocator() = default;
    template <typename U>
    CustomAllocator(const CustomAllocator<U>&) noexcept {}

    // 核心方法：分配与释放内存
    T* allocate(size_type n) {
        size_type total_size = n * sizeof(T);
        void* p = std::malloc(total_size);  // 自定义分配逻辑（如内存池）
        if (!p) throw std::bad_alloc();
        return static_cast<T*>(p);
    }

    void deallocate(T* p, size_type n) noexcept {
        std::free(p);  // 自定义释放逻辑
    }

    // 可选：构造与析构对象（默认调用 placement new 和析构函数）
    template <typename U, typename... Args>
    void construct(U* p, Args&&... args) {
        new (p) U(std::forward<Args>(args)...);
    }

    template <typename U>
    void destroy(U* p) {
        p->~U();
    }
};

// 支持不同模板参数分配器的相互转换（必须）
template <typename T, typename U>
bool operator==(const CustomAllocator<T>&, const CustomAllocator<U>&) { return true; }

template <typename T, typename U>
bool operator!=(const CustomAllocator<T>&, const CustomAllocator<U>&) { return false; }

3.2 使用自定义 Allocator

// 在容器中使用自定义分配器
std::vector<int, CustomAllocator<int>> vec;

// 使用分配器手动分配内存
CustomAllocator<int> alloc;
int* p = alloc.allocate(5);  // 分配 5 个 int 的空间
alloc.deallocate(p, 5);      // 释放

4 关键特性详解

4.1 `rebind` 机制

容器内部可能为辅助结构（如链表节点）分配内存，此时会通过 rebind 获取对应类型的分配器：

template <typename U>
struct rebind {
    using other = CustomAllocator<U>;
};

C++11 后：rebind 可以自动推断，但显式定义可提高兼容性。

4.2 状态化 Allocator

若分配器需要携带状态（如内存池句柄），需定义拷贝语义：

class StatefulAllocator {
    MemoryPool* pool;  // 携带状态
public:
    StatefulAllocator(MemoryPool* p) : pool(p) {}
    
    // 确保状态正确传递
    StatefulAllocator(const StatefulAllocator& other) : pool(other.pool) {}
    template <typename U>
    StatefulAllocator(const StatefulAllocator<U>& other) : pool(other.pool) {}
};

5 应用示例：内存池 Allocator

5.1 简单内存池实现

class MemoryPool {
private:
    std::vector<void*> blocks;  // 内存块列表
    static constexpr size_t BLOCK_SIZE = 4096;
    size_t current_pos = 0;

public:
    void* allocate(size_t size) {
        if (current_pos + size > BLOCK_SIZE) {
            blocks.push_back(std::malloc(BLOCK_SIZE));
            current_pos = 0;
        }
        void* p = static_cast<char*>(blocks.back()) + current_pos;
        current_pos += size;
        return p;
    }

    ~MemoryPool() {
        for (auto block : blocks) std::free(block);
    }
};

template <typename T>
class PoolAllocator {
private:
    MemoryPool* pool;  // 共享内存池

public:
    PoolAllocator(MemoryPool* p) : pool(p) {}
    template <typename U>
    PoolAllocator(const PoolAllocator<U>& other) : pool(other.pool) {}

    T* allocate(size_t n) {
        return static_cast<T*>(pool->allocate(n * sizeof(T)));
    }

    void deallocate(T* p, size_t n) noexcept {
        // 内存池通常延迟释放，此处不立即回收
    }
};

5.2 在容器中使用

MemoryPool pool;
std::vector<int, PoolAllocator<int>> vec((PoolAllocator<int>(&pool)));
vec.push_back(42);  // 使用内存池分配

6 调试与性能分析

自定义 allocator 可用于追踪内存使用：

template <typename T>
class DebugAllocator {
public:
    T* allocate(size_t n) {
        std::cout << "Allocating " << n * sizeof(T) << " bytes\n";
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }

    void deallocate(T* p, size_t n) noexcept {
        std::cout << "Deallocating " << n * sizeof(T) << " bytes\n";
        ::operator delete(p);
    }
};