概念

在 C++ 中，内存管理是一个重要的主题，它包括如何分配、使用和释放内存。与一些编程语言（如 Java 或 Python）使用自动垃圾回收机制不同，C++ 提供了更多灵活性，允许程序员直接控制内存管理。这种灵活性同时也带来了内存泄漏和悬挂指针等风险。

方法

栈内存管理

• 自动变量：使用局部变量时，内存是在栈上自动分配的。变量在函数作用域内有效，函数结束时自动释放。

void function() {  
    int a = 10;  // 自动分配在栈上  
}  // a 在这里被自动释放

• 快速且有效：栈上分配内存的速度快，因为栈只需要移动栈指针。

堆内存管理

• 动态内存分配：可以在运行时根据需要分配内存，使用 new 和 delete 操作符。

void function() {  
    int* p = new int;  // 动态分配内存  
    *p = 10;  
    delete p;  // 释放内存  
}

• 不自动释放：如果使用 new 分配内存而没有使用 delete 释放，将导致内存泄漏。

使用智能指针

为了简化内存管理并减少内存泄漏的风险，C++11 引入了智能指针。智能指针是封装了原始指针的对象，能够自动管理内存。

• std::unique_ptr：独占所有权，只能有一个指向该对象的智能指针。

#include <memory>  

void function() {  
    std::unique_ptr<int> p(new int(10)); // 动态分配内存  
    // 不需要手动 delete，当 p 超出作用域时自动释放内存  
}

• std::shared_ptr：允许多个智能指针共享同一个对象，通过引用计数来管理内存。

#include <memory>  

void function() {  
    std::shared_ptr<int> p1(new int(10));  // 创建一个shared_ptr  
    std::shared_ptr<int> p2 = p1;  // p2共享p1的资源  
    // 当 p1 和 p2 超出作用域时，自动释放内存  
}

• std::weak_ptr：与 std::shared_ptr 一起使用，提供了一种引用计数以外的访问方式。适用于解决循环引用的问题。

内存池（Memory Pool）

内存池是为特定类型的对象预分配一块较大的内存块，并以有效的方式进行管理。可以显著提升性能，减少内存碎片。

原理

• 预分配内存块：
  内存池在初始化时分配一大块内存。这块内存可以作为“池”，在此之后，从这个池中分配和释放内存，而不是频繁地向操作系统请求新的内存。

• 划分内存块：
  将大块内存划分为多个固定大小的小块。为每个块内部维护状态信息，以跟踪哪些块是可用的，哪些块已经被分配。

• 分配和释放：
  当需要分配内存时，内存池提供一个空闲块（通常使用链表或位图来跟踪可用块）。当对象被释放时，该块被标记为可用。

• 减少碎片：
  使用内存池可以显著减少内存碎片，因为所有的对象都是在一个块中分配的。

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

class MemoryPool {  
public:  
    MemoryPool(size_t blockSize, size_t blockCount)  
        : m_blockSize(blockSize), m_blockCount(blockCount) {  
        // 预分配内存池  
        m_memory = new char[blockSize * blockCount];  
        m_freeList.resize(blockCount);  
        for (size_t i = 0; i < blockCount; ++i) {  
            m_freeList[i] = m_memory + i * blockSize; // 初始化空闲列表  
        }  
    }  

    ~MemoryPool() {  
        delete[] m_memory; // 释放内存  
    }  

    void* allocate() {  
        if (m_freeList.empty()) {  
            throw std::bad_alloc(); // 内存池已满  
        }  
        void* ptr = m_freeList.back(); // 获取最后一个空闲块  
        m_freeList.pop_back(); // 从空闲列表中移除  
        return ptr;  
    }  

    void deallocate(void* ptr) {  
        m_freeList.push_back(ptr); // 将块添加回空闲列表  
    }  

private:  
    char* m_memory; // 内存池的基础内存  
    size_t m_blockSize; // 每个块的大小  
    size_t m_blockCount; // 块的数量  
    std::vector<void*> m_freeList; // 管理空闲块的列表  
};  

int main() {  
    const size_t blockSize = sizeof(int); // 分配 int 大小的内存块  
    const size_t blockCount = 10; // 预分配 10 个块  

    MemoryPool pool(blockSize, blockCount);  

    // 从内存池中分配内存  
    int* ptr1 = static_cast<int*>(pool.allocate());  
    int* ptr2 = static_cast<int*>(pool.allocate());  

    *ptr1 = 100;  
    *ptr2 = 200;  

    std::cout << "Allocated values: " << *ptr1 << ", " << *ptr2 << std::endl;  

    // 释放内存  
    pool.deallocate(ptr1);  
    pool.deallocate(ptr2);  

    return 0;  
}

代码解析

• MemoryPool 类：

  • 提供内存池的构造函数（接收块大小和块数量），在构造时预分配内存。
  • allocate() 函数用来从空闲列表中获取一个块，如果没有可用块，则引发 std::bad_alloc 异常。
  • deallocate() 函数将释放的块返回到空闲列表。

• 最后在 main() 函数中创建内存池并从中分配内存，最后释放内存。

优点

• 性能提升：
  内存池通过减少内存分配和释放的次数（避免对操作系统申请和释放内存）来提高性能。这对于大量小对象的分配尤其有效。

• 减少内存碎片：
  由于所有内存都来自一个大的池，内存池的管理避免了小块内存的分散，减少了内存碎片的发生。

• 更好的内存使用：
  内存池可以根据具体应用程序的需求，进行优化和定制，以提高内存使用效率。

缺点

• 管理复杂性：
  内存池的实现会增加代码的复杂性，需要设计内存分配逻辑，考虑内存对齐、并发等因素。

• 固定大小限制：
  通常情况下，内存池的块大小是固定的，可能导致空间浪费（内部碎片）。如果请求的内存大小不匹配池的大小，则不能直接满足请求。

• 难以扩展：
  一旦内存池的大小被固定，扩展可能比较困难，需要重建内存池或者动态调整。

内存分配器

C++ 允许开发人员自定义内存分配策略，通过重载 new 和 delete 操作符。

void* operator new(size_t size) {  
    // 自定义内存分配逻辑  
}  

void operator delete(void* pointer) {  
    // 自定义内存释放逻辑  
}

防止内存泄漏的良好实践

• 始终在不需要时释放动态分配的内存：确保每个 new 都有对应的 delete。
• 使用智能指针：尽量使用 std::unique_ptr 或 std::shared_ptr，减少手动管理内存的需要。
• 内存检查工具：使用工具如 Valgrind、AddressSanitizer 等来检查内存问题。
• 遵循 RAII 原则：即资源获取即初始化，在对象的构造过程中获取资源，在析构过程中释放资源。