提升效率的C++内存管理技巧

1.引言

        在C++编程中，内存管理是至关重要的环节，它直接影响着程序的性能和稳定性。合理地管理内存，不仅可以提升程序的运行效率，还能有效避免内存泄漏和野指针等问题。它不仅对程序的性能起着决定性作用，更是保障程序稳定性的关键所在。高效的内存管理能够极大地提升程序运行效率，减少资源浪费，而糟糕的内存管理则可能引发一系列问题，如内存泄漏、程序崩溃等，严重影响软件质量。下面介绍一下三个实用的C++内存管理技巧，帮助您更好地掌控内存，提升程序效率，有不正确的希望指出。

2.智能指针的使用

        在 C++ 早期，手动内存管理是常态，开发者需小心翼翼地使用new和delete操作符来分配和释放内存。这一过程繁琐且极易出错，一个小小的疏忽就可能导致内存泄漏，即已分配的内存不再被使用，却未能被正确释放，随着程序运行，内存占用不断增加，最终可能导致系统资源耗尽。例如：

int* ptr = new int;
// 后续代码中忘记delete ptr

        C++11及以后的版本引入了智能指针，极大地简化了内存管理的工作。智能指针主要包括std::unique_ptr、std::shared_ptr和std::weak_ptr。它们通过自动管理内存的生命周期，有效地避免了内存泄漏和悬空指针的问题。

2.1.std::unique_ptr

手撕代码：实现自己的unique_ptr_uniqueptr的实现-优快云博客

• std::unique_ptr是一种独占所有权的智能指针，即同一时间内只有一个unique_ptr可以指向给定资源。当unique_ptr离开作用域或被销毁时，它将自动释放其所管理的资源。

• 使用unique_ptr可以确保资源在不再需要时得到及时释放，避免了手动管理内存的繁琐和容易出错的问题。

• std::make_unique是 C++14 引入的函数，它用于创建std::unique_ptr，相较于直接使用new，它更为安全且高效，因为它能避免异常安全问题。

示例代码如下：

#include <memory>

int main() {
    std::unique_ptr<int> uPtr(new int(10)); // 创建一个指向int类型对象的unique_ptr
    //... 使用uPtr...
    // 无需手动释放内存，当uPtr离开作用域时，它将自动释放所管理的资源
    return 0;
}

2.2.std::shared_ptr

• std::shared_ptr是一种共享所有权的智能指针，允许多个shared_ptr实例共享对同一资源的拥有权。当最后一个引用该资源的shared_ptr被销毁时，资源会被自动释放。

• shared_ptr通过引用计数机制来管理资源的生命周期，确保了资源在不再被需要时得到及时释放。

• 虽然std::shared_ptr带来了极大的便利性，但由于引用计数的维护，它在性能上会有一定的开销，因此在使用时需权衡利弊。

示例代码如下：

#include <memory>

void func(std::shared_ptr<int> sPtr) {
    //... 使用sPtr...
}

int main() {
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(10); // 使用make_shared创建shared_ptr
    func(sharedPtr); // 将sharedPtr传递给函数
    // 当sharedPtr和func中的sPtr都离开作用域后，资源会被自动释放
    return 0;
}

2.3.std::weak_ptr

• std::weak_ptr是一种非拥有（"弱"）引用的智能指针。它指向由std::shared_ptr管理的对象，但是不增加引用计数。这避免了引用循环的问题，可以用来监测资源是否已被释放。

• 使用weak_ptr时，需要通过lock()函数来获取一个可用的shared_ptr，如果资源已被释放，lock()将返回一个空的shared_ptr。

示例代码如下：

#include <memory>

std::shared_ptr<int> globalSharedPtr;

int main() {
    globalSharedPtr = std::make_shared<int>(10);
    std::weak_ptr<int> weakPtr = globalSharedPtr; // 创建一个指向shared_ptr所管理资源的weak_ptr

    if (auto spt = weakPtr.lock()) { // 尝试获取一个shared_ptr
        //... 使用spt...
    } else {
        // 资源已被释放
    }

    globalSharedPtr.reset(); // 释放资源

    if (weakPtr.expired()) {
        // weakPtr指向的资源已被释放
    }

    return 0;
}

3.自定义内存池

        在某些场景下，需要频繁进行内存分配和释放，常规的内存分配方式（如new和delete）会带来显著的性能开销。这是因为每次调用new时，系统都需要在堆上查找合适的内存块，这涉及复杂的算法和系统调用，同样，delete操作也需要对释放的内存进行管理和回收。为了优化这种情况，内存池技术应运而生。

        内存池是一种内存管理机制，它预先分配一块较大的内存区域，作为内存池。当程序需要分配内存时，优先从内存池中获取，而不是向系统申请新的内存。当内存使用完毕后，也不立即归还给系统，而是将其放回内存池，以便后续再次使用。通过这种方式，减少了对系统内存分配函数的调用次数，从而提升了内存分配和释放的效率。

3.1.内存池的基本原理

• 内存池在程序启动时预先分配一大块内存，然后根据需要从中分配小块内存给程序使用。

• 当程序不再需要这些内存时，将它们归还给内存池，而不是直接释放回操作系统。

• 通过减少与操作系统的交互，内存池可以提高内存分配和释放的效率。

3.2.实现一个简单的内存池

• 定义一个内存池类，包含预先分配的内存块、空闲内存列表等成员变量。

• 实现内存分配和释放函数，从空闲内存列表中分配或回收内存。

示例代码如下：

#include <vector>
#include <iostream>

class MemoryPool {
private:
    std::vector<char> memoryBlock; // 预先分配的内存块
    std::vector<size_t> freeList; // 空闲内存列表

public:
    MemoryPool(size_t size) {
        memoryBlock.resize(size); // 预先分配内存
        freeList.push_back(0); // 初始时，整个内存块都是空闲的
    }

    void* allocate(size_t size) {
        if (freeList.empty()) {
            // 空闲内存列表为空，无法分配内存
            throw std::bad_alloc();
        }

        size_t index = freeList.front(); // 获取第一个空闲内存块的索引
        freeList.erase(freeList.begin()); // 从空闲列表中移除该空闲块

        if (index + size > memoryBlock.size()) {
            // 分配的内存超出了内存池的大小
            throw std::length_error("Memory pool allocation error");
        }

        if (index + size < memoryBlock.size()) {
            // 分配后还有剩余空闲内存，将其添加到空闲列表中
            freeList.push_back(index + size);
        }

        return &memoryBlock[index]; // 返回分配的内存地址
    }

    void deallocate(void* ptr) {
        size_t index = ptr - &memoryBlock[0]; // 计算内存块在内存池中的索引
        freeList.push_back(index); // 将内存块添加到空闲列表中
        std::sort(freeList.begin(), freeList.end()); // 对空闲列表进行排序，以便更高效地分配内存
    }
};

int main() {
    MemoryPool pool(1024); // 创建一个大小为1024字节的内存池

    void* p1 = pool.allocate(100); // 分配100字节的内存
    void* p2 = pool.allocate(200); // 分配200字节的内存

    //... 使用p1和p2...

    pool.deallocate(p1); // 释放p1所指向的内存
    pool.deallocate(p2); // 释放p2所指向的内存

    return 0;
}

4.RAII（Resource Acquisition Is Initialization）技术

C++惯用法之RAII思想: 资源管理_raii 思想-优快云博客

        RAII是一种利用对象生命周期来管理资源的编程技术。在C++中，通过构造函数获取资源，并在析构函数中释放资源，可以确保资源在对象生命周期结束时得到正确释放。

       RAII的优势

• 资源管理更加简单和可靠，无需显式地释放资源。

• 避免了资源泄漏和异常安全问题，即使在函数中途抛出异常，资源也能得到正确释放。

• 提高了代码的可读性和可维护性。

示例代码：使用RAII管理文件资源

创建一个文件管理类，在构造函数中打开文件，在析构函数中关闭文件。

#include <iostream>
#include <fstream>

class File {
private:
    std::fstream file;

public:
    File(const std::string& filename, const std::ios_base::openmode mode) {
        file.open(filename, mode); // 在构造函数中打开文件
        if (!file.is_open()) {
            throw std::runtime_error("Failed to open file");
        }
    }

    ~File() {
        file.close(); // 在析构函数中关闭文件
    }

    //... 其他文件操作函数...

};

int main() {
    try {
        File file("example.txt", std::ios::out); // 创建File对象，打开文件
        //... 使用file对象进行文件操作...
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }

    // 无需显式关闭文件，当file对象离开作用域时，其析构函数会自动关闭文件

    return 0;
}

5.总结        

        通过合理地使用智能指针、自定义内存池和RAII技术，（其实智能指针也使用了RAII技术），我们可以更好地管理C++程序中的内存，提升程序的性能和稳定性。这些技巧不仅简化了内存管理的工作，还降低了内存泄漏和野指针等问题的风险。在实际开发中，根据具体场景选择合适的技巧，将有助于我们编写出高效、可靠的C++程序。

        希望以上三个C++内存管理技巧能对广大开发者有所帮助，让我们一起在C++编程的道路上不断前行，探索更多高效、优雅的编程方法。