编辑“︁C++ 自定义内存管理”︁（章节）

== 实现方法 ==  

=== 1. 重载 `operator new` 和 `operator delete` ===  
通过重载全局或类特定的内存操作符，可以自定义内存分配逻辑。  

<syntaxhighlight lang="cpp">  
#include <iostream>  
#include <cstdlib>  

class CustomMemory {  
public:  
    // 重载类专属 operator new  
    static void* operator new(size_t size) {  
        std::cout << "Custom new: Allocating " << size << " bytes\n";  
        return malloc(size);  
    }  

    // 重载类专属 operator delete  
    static void operator delete(void* ptr) noexcept {  
        std::cout << "Custom delete: Freeing memory\n";  
        free(ptr);  
    }  
};  

int main() {  
    CustomMemory* obj = new CustomMemory();  
    delete obj;  
    return 0;  
}  
</syntaxhighlight>  

'''输出'''：  
<pre>  
Custom new: Allocating 1 bytes  
Custom delete: Freeing memory  
</pre>  

=== 2. 内存池（Memory Pool） ===  
预先分配一大块内存，并在内部管理小块内存的分配与释放。  

<mermaid>  
graph LR  
    A[Memory Pool] --> B[预分配大块内存]  
    B --> C[分割为固定大小块]  
    C --> D[按需分配]  
    D --> E[回收释放的块]  
</mermaid>  

'''示例代码'''：  
<syntaxhighlight lang="cpp">  
#include <vector>  

class MemoryPool {  
    std::vector<void*> blocks;  
public:  
    void* allocate(size_t size) {  
        void* block = malloc(size);  
        blocks.push_back(block);  
        return block;  
    }  

    ~MemoryPool() {  
        for (auto block : blocks) free(block);  
    }  
};  
</syntaxhighlight>  

=== 3. 自定义分配器（Allocator） ===  
STL容器允许通过自定义分配器控制内存来源。以下是一个简单的线性分配器：  

<syntaxhighlight lang="cpp">  
template <typename T>  
class LinearAllocator {  
    char* pool;  
    size_t offset;  
public:  
    LinearAllocator(size_t size) : pool(new char[size]), offset(0) {}  

    T* allocate(size_t n) {  
        void* ptr = pool + offset;  
        offset += n * sizeof(T);  
        return static_cast<T*>(ptr);  
    }  

    void deallocate(T*, size_t) noexcept {} // 线性分配器通常不释放单个对象  
};  
</syntaxhighlight>