如何在 C++ 框架中进行高效的内存回收

在C++编程中，内存管理是一项非常重要且复杂的工作。内存回收的效率直接影响到程序的性能和稳定性。如果不恰当地管理内存，可能会导致内存泄漏和性能下降等问题。这篇文章将探讨如何在C++框架中进行高效的内存回收，主要从以下几个方面进行介绍：智能指针、内存池、RAII（Resource Acquisition Is Initialization）以及自定义分配器。

智能指针

智能指针是C++11引入的一种内存管理工具，用于自动管理对象的生命周期，避免手动释放内存带来的困扰。智能指针主要有两种类型：`std::shared_ptr` 和 `std::unique_ptr`。

shared_ptr

`std::shared_ptr`用于共享所有权的内存管理。当最后一个`shared_ptr`被销毁时，管辖的对象才会被释放。

#include 
#include 
int main() {
    std::shared_ptr p1 = std::make_shared(42);
    std::shared_ptr p2 = p1; // 共享所有权
    std::cout << *p1 << std::endl; // 输出 42
    std::cout << p1.use_count() << std::endl; // 输出 2
    return 0;
}

unique_ptr

`std::unique_ptr`用于独占所有权的内存管理。一个`unique_ptr`不能被复制，只能被移动。

#include 
#include 
int main() {
    std::unique_ptr p1 = std::make_unique(42);
    // std::unique_ptr p2 = p1; // 错误，不能复制
    std::unique_ptr p2 = std::move(p1); // 所有权转移
    std::cout << *p2 << std::endl; // 输出 42
    return 0;
}

内存池

内存池（Memory Pool）是一种优化的内存管理策略，通过预先分配一大块内存，然后按需分配和释放这块内存中的小块，从而减少内存分配和释放的开销。

实现内存池

下面是一个简单的内存池实现示例：

#include 
#include 
class MemoryPool {
public:
    MemoryPool(size_t block_size, size_t block_count) :
        block_size_(block_size), block_count_(block_count), pool_(block_size * block_count), free_blocks_(block_count) {
        for (size_t i = 0; i < block_count_; ++i) {
            free_blocks_[i] = pool_.data() + i * block_size_;
        }
    }
    void* Allocate() {
        if (free_blocks_.empty()) {
            return nullptr; // 没有可用的内存块
        }
        void* block = free_blocks_.back();
        free_blocks_.pop_back();
        return block;
    }
    void Deallocate(void* block) {
        free_blocks_.push_back(block);
    }
private:
    size_t block_size_;
    size_t block_count_;
    std::vector pool_;
    std::vector free_blocks_;
};
int main() {
    MemoryPool pool(256, 10); // 创建内存池，每块256字节，共10块
    void* block1 = pool.Allocate();
    void* block2 = pool.Allocate();
    
    pool.Deallocate(block1);
    pool.Deallocate(block2);
    return 0;
}

RAII（Resource Acquisition Is Initialization）

RAII是一种C++编程范式，在资源获取时立即进行初始化，并在对象离开作用域时自动释放资源。使用RAII可以确保无论程序控制流如何变化，资源都能正确地释放。

RAII示例

#include 
class FileHandler {
public:
    FileHandler(const char* filename) {
        file_ = fopen(filename, "w");
    }
    ~FileHandler() {
        if (file_) {
            fclose(file_);
        }
    }
    void Write(const char* message) {
        if (file_) {
            fprintf(file_, "%s", message);
        }
    }
private:
    FILE* file_;
};
int main() {
    FileHandler fh("example.txt");
    fh.Write("Hello, RAII!");
    return 0;
}

自定义分配器

自定义分配器允许开发者控制内存的分配和释放过程，可以极大提升内存管理的效率。C++标准库中的容器支持自定义分配器。

实现自定义分配器

以下是一个简单的自定义分配器示例：

#include 
#include 
template
class CustomAllocator {
public:
    using value_type = T;
    CustomAllocator() = default;
    template
    constexpr CustomAllocator(const CustomAllocator&) noexcept {}

    T* allocate(std::size_t n) {
        if (n > std::size_t(-1) / sizeof(T))
            throw std::bad_alloc();
        if (auto p = static_cast(std::malloc(n * sizeof(T)))) {
            return p;
        }
        throw std::bad_alloc();
    }
    void deallocate(T* p, std::size_t) noexcept {
        std::free(p);
    }
};
int main() {
    std::vector> vec{1, 2, 3, 4, 5};
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    return 0;
}