C++基本组件之内存池详解

什么是内存池？

内存池是一种用于管理内存分配和释放的技术。它通过预先分配一块连续的内存空间，并将其划分为多个固定大小的块，以提高内存分配和释放的效率。内存池可以减少频繁的内存分配和释放操作，从而提高程序的性能。

内存池的实现原理

内存池的实现原理如下：

1. 预先分配一块连续的内存空间。
2. 将内存空间划分为多个固定大小的块。
3. 使用一个数据结构（如链表）来管理这些块的分配和释放状态。
4. 当需要分配内存时，从空闲块中选择一个合适大小的块，并将其标记为已分配。
5. 当需要释放内存时，将已分配的块标记为未分配，并将其放回空闲块中。

内存池的优势

使用内存池的优势如下：

1. 提高内存分配和释放的效率：由于内存池预先分配了一块连续的内存空间，并将其划分为固定大小的块，因此可以避免频繁的内存分配和释放操作，提高程序的性能。
2. 减少内存碎片：内存池使用固定大小的块进行内存分配，可以减少内存碎片的产生，提高内存利用率。
3. 控制内存分配的策略：内存池可以根据实际需求控制内存分配的策略，如固定大小的块、按需分配等。

内存池的示例

下面是两个示例，演示了如何使用内存池进行内存分配和释放。

示例一：固定大小的内存池

#include <iostream>
#include <vector>

class MemoryPool {
private:
    std::vector<char*> blocks;
    std::vector<bool> isAllocated;
    size_t blockSize;
    size_t numBlocks;

public:
    MemoryPool(size_t blockSize, size_t numBlocks) : blockSize(blockSize), numBlocks(numBlocks) {
        blocks.resize(numBlocks);
        isAllocated.resize(numBlocks, false);
        for (size_t i = 0; i < numBlocks; ++i) {
            blocks[i] = new char[blockSize];
        }
    }

    ~MemoryPool() {
        for (size_t i = 0; i < numBlocks; ++i) {
            delete[] blocks[i];
        }
    }

    void* allocate() {
        for (size_t i = 0; i < numBlocks; ++i) {
            if (!isAllocated[i]) {
                isAllocated[i] = true;
                return blocks[i];
            }
        }
        return nullptr;
    }

    void deallocate(void* ptr) {
        for (size_t i = 0; i < numBlocks; ++i) {
            if (blocks[i] == ptr) {
                isAllocated[i] = false;
                break;
            }
        }
    }
};

int main() {
    MemoryPool pool(16, 10);

    int* p1 = static_cast<int*>(pool.allocate());
    *p1 = 42;

    int* p2 = static_cast<int*>(pool.allocate());
    *p2 = 24;

    std::cout << *p1 << std::endl;  // Output: 42
    std::cout << *p2 << std::endl;  // Output: 24

    pool.deallocate(p1);
    pool.deallocate(p2);

    return 0;
}

示例二：按需分配的内存池

#include <iostream>
#include <vector>

class MemoryPool {
private:
    std::vector<char*> blocks;
    std::vector<bool> isAllocated;
    size_t blockSize;
    size_t numBlocks;

public:
    MemoryPool(size_t blockSize) : blockSize(blockSize), numBlocks(0) {}

    ~MemoryPool() {
        for (size_t i = 0; i < numBlocks; ++i) {
            delete[] blocks[i];
        }
    }

    void* allocate() {
        if (numBlocks == 0) {
            blocks.push_back(new char[blockSize]);
            isAllocated.push_back(false);
            ++numBlocks;
        }

        for (size_t i = 0; i < numBlocks; ++i) {
            if (!isAllocated[i]) {
                isAllocated[i] = true;
                return blocks[i];
            }
        }

        blocks.push_back(new char[blockSize]);
        isAllocated.push_back(false);
        ++numBlocks;

        return blocks[numBlocks - 1];
    }

    void deallocate(void* ptr) {
        for (size_t i = 0; i < numBlocks; ++i) {
            if (blocks[i] == ptr) {
                isAllocated[i] = false;
                break;
            }
        }
    }
};

int main() {
    MemoryPool pool(16);

    int* p1 = static_cast<int*>(pool.allocate());
    *p1 = 42;

    int* p2 = static_cast<int*>(pool.allocate());
    *p2 = 24;

    std::cout << *p1 << std::endl;  // Output: 42
    std::cout << *p2 << std::endl;  // Output: 24

    pool.deallocate(p1);
    pool.deallocate(p2);

    return 0;
}

以上示例展示了两种常见的内存池实现方式：固定大小的内存池和按需分配的内存池。你可以根据实际需求选择适合的内存池实现方式。