学懂C++（四十四）：C++ 自定义内存管理的深入解析：内存池与自定义分配器

于 2024-08-26 12:47:32 发布
阅读量569 收藏 6
点赞数 13
分类专栏： 学懂C++语言-C++核心编程精讲 文章标签： c++ 开发语言 自定义内存管理 内存池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/martian665/article/details/141561146
版权

目录

1. 内存池（Memory Pool）

概念

模型

特点

核心点

实现

适用场景

经典示例实现

代码解析

2. 自定义分配器（Custom Allocators）

概念

模型

特点

核心点

实现

适用场景

经典示例实现

代码解析

高级自定义分配器示例

代码解析

总结

        C++作为一种高性能编程语言，在处理内存管理方面提供了极大的灵活性。默认情况下，C++使用操作系统提供的内存分配和释放机制（如new、delete、malloc和free）。然而，在某些高性能或特定需求的应用中，默认的内存管理机制可能无法满足需求。这时，自定义内存管理技术，如内存池（Memory Pool）和自定义分配器（Custom Allocators），可以提供更高效、更灵活的内存管理方案。

        本文将详细介绍内存池和自定义分配器在C++中的应用，包含其概念、模型、特点、核心点、实现方法、适用场景，以及经典示例代码和详细解析。

1. 内存池（Memory Pool）

概念

        内存池是一种自定义内存管理机制，通过预分配一大块内存并将其划分成多个固定大小的块，从而实现快速的内存分配和释放。这种技术特别适用于频繁分配和释放相同大小对象的场景。

模型

  • 预分配内存块：一次性分配一大块连续的内存。
  • 分割内存块：将大块内存划分为多个固定大小的小块。
  • 空闲块管理：维护一个空闲块的列表，用于快速分配和释放内存。

特点

  • 高效性：内存分配和释放操作可以在常数时间内完成。
  • 减少碎片：通过固定大小的块减少内存碎片问题。
  • 预分配：内存池一次性分配大块内存，减少多次分配带来的开销。

核心点

  • 预先分配足够大的内存块。
  • 维护空闲块列表，实现快速分配和释放。

实现

#include <iostream>
#include <vector>
#include <cassert>

class MemoryPool
{
private:
    struct Block
    {
        Block* next;
    };

    Block* freeBlocks; // 空闲块链表头指针
    std::vector<void*> pool; // 用于存储内存块的指针数组

    void allocatePool(size_t blockSize, size_t blockCount)
    {
        // 分配一大块连续内存
        void* newPool = operator new(blockSize * blockCount);
        pool.push_back(newPool);

        Block* head = static_cast<Block*>(newPool);
        freeBlocks = head;

        // 初始化空闲块链表
        for (size_t i = 1; i < blockCount; ++i)
        {
            head->next = reinterpret_cast<Block*>(reinterpret_cast<char*>(head) + blockSize);
            head = head->next;
        }
        head->next = nullptr;
    }

public:
    MemoryPool(size_t blockSize, size_t blockCount)
    {
        allocatePool(blockSize, blockCount);
    }

    ~MemoryPool()
    {
        // 释放所有内存块
        for (void* ptr : pool)
        {
            operator delete(ptr);
        }
    }

    void* allocate()
    {
        if (!freeBlocks)
        {
            // 如果没有空闲块，则分配新的内存池
            throw std::bad_alloc();
        }

        // 从空闲块链表中取出一个块
        Block* block = freeBlocks;
        freeBlocks = freeBlocks->next;
        return block;
    }

    void deallocate(void* ptr)
    {
        // 将块返回到空闲块链表中
        Block* block = static_cast<Block*>(ptr);
        block->next = freeBlocks;
        freeBlocks = block;
    }
};

适用场景

  • 高性能应用：如游戏开发中的对象池、网络服务器的连接管理等。
  • 频繁分配和释放相同大小对象：如内存块、节点对象等。

经典示例实现

#include <iostream>
#include <vector>
#include <cassert>

class MemoryPool
{
private:
    struct Block
    {
        Block* next;
    };

    Block* freeBlocks; // 空闲块链表头指针
    std::vector<void*> pool; // 用于存储内存块的指针数组

    void allocatePool(size_t blockSize, size_t blockCount)
    {
        // 分配一大块连续内存
        void* newPool = operator new(blockSize * blockCount);
        pool.push_back(newPool);

        Block* head = static_cast<Block*>(newPool);
        freeBlocks = head;

        // 初始化空闲块链表
        for (size_t i = 1; i < blockCount; ++i)
        {
            head->next = reinterpret_cast<Block*>(reinterpret_cast<char*>(head) + blockSize);
            head = head->next;
        }
        head->next = nullptr;
    }

public:
    MemoryPool(size_t blockSize, size_t blockCount)
    {
        allocatePool(blockSize, blockCount);
    }

    ~MemoryPool()
    {
        // 释放所有内存块
        for (void* ptr : pool)
        {
            operator delete(ptr);
        }
    }

    void* allocate()
    {
        if (!freeBlocks)
        {
            // 如果没有空闲块，则分配新的内存池
            throw std::bad_alloc();
        }

        // 从空闲块链表中取出一个块
        Block* block = freeBlocks;
        freeBlocks = freeBlocks->next;
        return block;
    }

    void deallocate(void* ptr)
    {
        // 将块返回到空闲块链表中
        Block* block = static_cast<Block*>(ptr);
        block->next = freeBlocks;
        freeBlocks = block;
    }
};

class Widget
{
public:
    int x, y, z;

    Widget(int a, int b, int c) : x(a), y(b), z(c) {}

    void display()
    {
        std::cout << "Widget(" << x << ", " << y << ", " << z << ")" << std::endl;
    }

    // 重载new操作符
    static void* operator new(size_t size)
    {
        return pool.allocate();
    }

    // 重载delete操作符
    static void operator delete(void* ptr)
    {
        pool.deallocate(ptr);
    }

private:
    static MemoryPool pool;
};

// 初始化静态内存池
MemoryPool Widget::pool(sizeof(Widget), 10);

int main()
{
    std::vector<Widget*> widgets;

    // 分配Widget对象
    for (int i = 0; i < 10; ++i)
    {
        widgets.push_back(new Widget(i, i + 1, i + 2));
    }

    // 显示Widget对象
    for (Widget* widget : widgets)
    {
        widget->display();
    }

    // 释放Widget对象
    for (Widget* widget : widgets)
    {
        delete widget;
    }

    return 0;
}

代码解析

  1. MemoryPool类：实现内存池管理，包括分配和释放内存块。
  2. Widget类：示例对象类，重载了new和delete操作符以使用内存池进行内存管理。
  3. main函数：展示了如何使用内存池分配和释放Widget对象。

2. 自定义分配器（Custom Allocators）

概念

自定义分配器是C++标准库（STL）中的一种机制，允许开发者控制容器的内存分配策略。通过自定义分配器，开发者可以替换默认的内存分配方式，以满足特定的性能需求或内存管理策略。

模型

  • 分配器类：实现内存分配和释放的接口（如allocate和deallocate方法）。
  • 容器类：使用自定义分配器进行内存管理。

特点

  • 灵活性：开发者可以完全控制内存分配和释放。
  • 可扩展性：可以根据具体需求实现不同的内存管理策略。

核心点

  • 实现分配器类，提供allocate和deallocate方法。
  • 在容器中使用自定义分配器。

实现

#include <iostream>
#include <memory>
#include <vector>

template <typename T>
class CustomAllocator
{
public:
    using value_type = T;

    CustomAllocator() = default;

    template <typename U>
    CustomAllocator(const CustomAllocator<U>&) {}

    T* allocate(std::size_t n)
    {
        std::cout << "Allocating " << n << " element(s)" << std::endl;
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }

    void deallocate(T* ptr, std::size_t n)
    {
        std::cout << "Deallocating " << n << " element(s)" << std::endl;
        ::operator delete(ptr);
    }
};

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;
}

适用场景

  • 高性能应用：如游戏开发中的对象池、实时系统的内存管理等。
  • 特定内存管理需求：如内存对齐、内存池管理等。

经典示例实现

#include <iostream>
#include <memory>
#include <vector>

// 自定义分配器类
template <typename T>
class CustomAllocator
{
public:
    using value_type = T;

    CustomAllocator() = default;

    template <typename U>
    CustomAllocator(const CustomAllocator<U>&) {}

    T* allocate(std::size_t n)
    {
        std::cout << "Allocating " << n << " element(s)" << std::endl;
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }

    void deallocate(T* ptr, std::size_t n)
    {
        std::cout << "Deallocating " << n << " element(s)" << std::endl;
        ::operator delete(ptr);
    }
};

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;
}

int main()
{
    // 使用自定义分配器的vector容器
    std::vector<int, CustomAllocator<int>> vec;

    // 添加元素
    for (int i = 0; i < 5; ++i)
    {
        vec.push_back(i);
    }

    // 显示元素
    for (int i : vec)
    {
        std::cout << i << std::endl;
    }

    return 0;
}

代码解析

  1. CustomAllocator类：实现自定义分配器，包括allocate和deallocate方法。
  2. operator==和operator!=：定义分配器的比较操作符。
  3. main函数：展示了如何使用自定义分配器创建vector容器，并进行元素的添加和显示。

高级自定义分配器示例

#include <iostream>
#include <memory>
#include <vector>

// 高级自定义分配器类
template <typename T>
class AdvancedAllocator
{
public:
    using value_type = T;

    AdvancedAllocator() = default;

    template <typename U>
    AdvancedAllocator(const AdvancedAllocator<U>&) {}

    T* allocate(std::size_t n)
    {
        std::cout << "Advanced Allocator: Allocating " << n << " element(s)" << std::endl;
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }

    void deallocate(T* ptr, std::size_t n)
    {
        std::cout << "Advanced Allocator: Deallocating " << n << " element(s)" << std::endl;
        ::operator delete(ptr);
    }

    template <typename U, typename... Args>
    void construct(U* p, Args&&... args)
    {
        std::cout << "Advanced Allocator: Constructing element" << std::endl;
        ::new((void*)p) U(std::forward<Args>(args)...);
    }

    template <typename U>
    void destroy(U* p)
    {
        std::cout << "Advanced Allocator: Destroying element" << std::endl;
        p->~U();
    }
};

template <typename T, typename U>
bool operator==(const AdvancedAllocator<T>&, const AdvancedAllocator<U>&)
{
    return true;
}

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

int main()
{
    // 使用高级自定义分配器的vector容器
    std::vector<int, AdvancedAllocator<int>> vec;

    // 添加元素
    for (int i = 0; i < 5; ++i)
    {
        vec.push_back(i);
    }

    // 显示元素
    for (int i : vec)
    {
        std::cout << i << std::endl;
    }

    return 0;
}

代码解析

  1. AdvancedAllocator类：在CustomAllocator基础上，增加了construct和destroy方法，用于元素的构造和析构。
  2. operator==和operator!=：定义分配器的比较操作符。
  3. main函数：展示了如何使用高级自定义分配器创建vector容器，并进行元素的添加和显示。

总结

        自定义内存管理技术，如内存池和自定义分配器，在C++中提供了强大的内存管理能力。它们不仅能够提高内存管理的效率，还能满足特定应用场景下的内存管理需求。

  • 内存池（Memory Pool）：通过预分配一大块内存并将其划分成多个固定大小的块，实现高效的内存分配和释放。适用于高性能应用和频繁分配和释放相同大小对象的场景。
  • 自定义分配器（Custom Allocators）：允许开发者控制容器的内存分配策略，满足特定的性能需求或内存管理策略。适用于高性能应用和特定内存管理需求的场景。

        通过以上示例代码和详细解析，开发者可以更好地理解和应用自定义内存管理技术，从而提高软件质量和开发效率。

猿享天开
关注
  • 13
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
虚拟机内存管理之内存分配器
YZcoder的博客
09-01 2068
本文意在通过深入剖析常用的内存分配器的关键实现，以理解虚拟机动态内存管理的设计哲学，并为实现虚拟机高效的内存管理提供指引。
【C++智能指针】深入探究C++智能指针：自定义删除器的设计与选择
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
09-05 899
在C++编程中，内存管理一直是一个不可或缺的话题。传统的C++程序员依赖`new`和`delete`（新建和删除）来手动管理内存，但这种方式容易导致内存泄漏或是双重释放等问题。这就是智能指针（Smart Pointers）登场的原因。 智能指针不仅仅是一个指针，它是一个对象，拥有生命周期（Lifetime）。当智能指针的生命周期结束时，它会自动释放所拥有的资源。这种自动管理机制极大地减少了程序员的负担，也降低了出错的可能性。
深入解析C++ JSON库：nlohmann::json:: parse的内部机制与应用
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
07-25 2901
JSON解析是将JSON格式的字符串转换为程序可以操作的数据结构的过程。在C++中，通常会将JSON数据解析为一种特殊的数据类型，如`nlohmann::json`，这种数据类型可以方便地访问和操作JSON数据。 在解析过程中，我们需要处理各种JSON元素，如对象（object）、数组（array）、字符串（string）、数字（number）、布尔值（boolean）和null。每种元素都对应一种或多种C++类型，例如，JSON对象对应C++的`std::map`或`std::unordered_map
C/C++内存管理详解
做技术人 · 产优质博客 · 找好工作
07-05 3814
本文主要从C/C++五大内存布局入手，整体贯穿性地介绍C++中new/delete的用法，带你掌握并吃透内存管理技术
探索内存管理的艺术：高效自定义分配器
gitblog_00020的博客
05-13 385
探索内存管理的艺术：高效自定义分配器 memory-allocatorsCustom memory allocators in C++ to improve the performance of dynamic memory allocation项目地址:https://gitcode.com/gh_mirrors/me/memory-allocators 在软件开发中，动态内存管理是不可或缺的...
【C++ std::variant】深入探索 C++ std::variant：构造方法与实践应用
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
01-09 1068
`std::variant`，或称标准变体，是 C++17 标准库引入的一种类型，用于安全地存储并访问多种类型中的一种。此特性在编程中的引入，反映了人们对灵活性和效率的追求，这正符合心理学中对人类追求效率和适应性的观点。
C++20新特性解析：深入探讨协程库的实现原理与应用
Lion_Long的博客
01-07 2826
C++20引入了对协程的支持，这是一项重要的编程语言特性，可以简化异步编程的实现而且提高代码的可读性和可维护性。协程可以在执行过程中暂停和恢复，能够更直观地表达异步操作的流程，让编程更加简洁和高效。C++20的协程库提供了一组新的关键字、库函数和概念，能轻松地实现异步操作、事件驱动的编程模型和无阻塞式IO等。这些特性对于网络编程、并发编程和响应式编程都有很大的帮助。
深入解析C++树形关联式容器：map、set及其衍生容器的使用与原理
无敌岩雀的博客
03-13 1750
关联式容器是C++标准库中的一种重要数据结构，它允许我们存储键值对（key-value pair）或单独的元素，并基于键（key）来快速访问或检索对应的值（value）或元素。关联式容器在多种场景下发挥着至关重要的作用，特别是在需要高效查找、插入和删除元素时。它们为程序员提供了便捷的工具，可以简化复杂的操作，并优化程序性能。
C++环形缓冲区设计与实现：从原理到应用的全方位解析
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
05-28 2414
C++环形缓冲区设计与实现：从原理到应用的全方位解析
C++类与动态内存分配
Jasmine-Lily的博客
11-20 887
C++类与动态内存分配
json-writer.zip_C++_JSON_Json::Writer_jsonwriter_解析json
09-15
4. **性能优化**：由于描述中提到解析速度快，这个实现可能包含了一些优化技术，如减少内存分配、缓存重复字符串等。 为了使用`json::Writer`，你需要包含相应的头文件，实例化Writer对象，然后调用其方法来构建或...
c++内存搜索学习
10-08
C++允许程序员直接管理内存，通过`new`运算符动态分配内存，`delete`运算符释放内存。程序中的变量和对象都在内存中占据位置，每个都有一个唯一的内存地址。理解栈、堆、静态存储区和常量存储区的区别至关重要，因为...
牛客校招面试题（附答案与解析）c++
07-31
这个“牛客校招面试题（附答案与解析）c++”的资源对于准备C++面试的求职者来说非常有价值，它提供了实战练习和深入理解C++的机会。通过解答这些题目，应聘者可以检验自己的知识水平，发现不足，并通过解析学习到更...
深入理解C++11新特性解析与应用
11-08
### 深入理解C++11新特性解析与应用 #### 一、引言 随着计算机科学的发展，编程语言也在不断进化以适应新的需求和技术挑战。C++作为一种广泛使用的编程语言，在2011年推出了C++11标准，带来了大量的改进和新特性。...
QT5.10+VS写的高仿CE进程内存视图源码
05-13
而在这个项目中，开发者可能使用了Qt的信号和槽机制来实时更新内存视图，这允许UI界面与内存读取操作进行同步。 在实现过程中，可能涉及到以下几个关键知识点： 1. **Qt Widgets**：创建窗口和控件，如QLabel、...
C语言：文件（写入，读取）
2301_80311224的博客
08-21 707
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
【C++】链表
qq_38801607的博客
08-22 556
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
C++ 重载运算符和重载函数
lly202406的博客
08-25 373
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
【C语言篇】
最新发布
2301_81072404的博客
08-25 92
条件编译（#ifdef、#ifndef、#else、#elif、#endif）指针与动态内存分配（malloc、calloc、realloc、free）文件的读写操作（fread、fwrite、fprintf、fscanf等）控制语句（if、for、while、do-while、switch等）字符串处理函数（strlen、strcpy、strcat等）运算符（算术运算符、关系运算符、逻辑运算符等）文件的打开与关闭（fopen、fclose）数据类型（整型、浮点型、字符型等）函数参数传递（传值、传址）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值