白骑士的C++教学高级篇 3.3 内存管理

系列目录

上一篇：白骑士的C++教学高级篇 3.2 多线程与并发

        内存管理是C++编程中的一个关键方面，它直接关系到程序的性能和稳定性。良好的内存管理可以避免内存泄漏和未定义行为，使程序更加健壮和高效。C++11引入了一些新的工具，如智能指针和RAII（资源获取即初始化），极大地简化了内存管理的复杂性。本篇内容将详细介绍动态内存分配与释放、智能指针以及RAII，帮助掌握C++中的内存管理技巧。

动态内存分配与释放

        动态内存分配允许程序在运行时请求内存，而不是在编译时分配固定大小的内存块。C++使用 ‘new‘ 和 ‘delete‘ 运算符进行动态内存分配和释放。

动态内存分配

        使用 ‘new‘ 运算符可以在堆上分配内存，并返回指向该内存的指针，例如：

#include <iostream>


int main() {
    int* p = new int; // 动态分配一个整数
    *p = 10;

    std::cout << "Value: " << *p << std::endl;

    delete p; // 释放内存

    return 0;
}

        在上面的代码中，我们使用 ‘new‘ 运算符在堆上分配了一个整数，并将其值设置为10。最后使用 ‘delete‘ 运算符释放该内存。

动态数组分配

        动态内存分配不仅可以用于单个变量，还可以用于数组，例如：

#include <iostream>


int main() {
    int* arr = new int[5]; // 动态分配一个包含5个整数的数组

    for (int i = 0; i < 5; ++i) {
        arr[i] = i * 10;
    }

    for (int i = 0; i < 5; ++i) {
        std::cout << "arr[" << i << "] = " << arr[i] << std::endl;
    }

    delete[] arr; // 释放数组内存

    return 0;
}

        在这段代码中，我们使用 ‘new[]‘ 运算符动态分配了一个包含5个整数的数组，并使用 ‘delete[]‘ 运算符释放该内存。

智能指针

        智能指针是C++11引入的一种新的内存管理工具，它们能够自动管理动态内存的生命周期，避免内存泄漏和悬空指针问题。C++标准库提供了三种主要的智能指针：‘unique_ptr‘、‘shared_ptr‘ 和 ‘weak_ptr‘。

unique_ptr

        ‘unique_ptr‘ 是独占所有权的智能指针，确保同一时间只有一个指针指向给定的动态内存。使用 ‘unique_ptr‘ 可以防止资源泄漏，并确保资源的所有权明确，例如：

#include <iostream>
#include <memory>


int main() {
    std::unique_ptr<int> p1(new int(10));
    std::cout << "Value: " << *p1 << std::endl;

    // 不能复制unique_ptr

    // std::unique_ptr<int> p2 = p1; // 错误

    // 可以转移所有权
    std::unique_ptr<int> p3 = std::move(p1);
    std::cout << "Value: " << *p3 << std::endl;

    return 0;
}

        在这段代码中，我们使用 ‘unique_ptr‘ 管理动态内存，并展示了如何转移所有权。

shared_ptr

        ‘shared_ptr‘ 是共享所有权的智能指针，多个 ‘shared_ptr‘ 可以指向同一块动态内存，内存会在最后一个 ‘shared_ptr‘ 销毁时自动释放，例如：

#include <iostream>
#include <memory>


int main() {
    std::shared_ptr<int> p1(new int(20));
    std::shared_ptr<int> p2 = p1;

    std::cout << "p1 use count: " << p1.use_count() << std::endl;
    std::cout << "p2 use count: " << p2.use_count() << std::endl;

    p1.reset();

    std::cout << "p1 use count after reset: " << p1.use_count() << std::endl;
    std::cout << "p2 use count after reset: " << p2.use_count() << std::endl;

    return 0;
}

        在这段代码中，我们使用 ‘shared_ptr‘ 管理动态内存，并展示了共享所有权的概念和使用计数。

weak_ptr

        ‘weak_ptr‘ 是一种不拥有对象所有权的智能指针，它与 ‘shared_ptr‘ 协同工作，解决循环引用问题，例如：

#include <iostream>
#include <memory>


class Node {
public:
    std::shared_ptr<Node> next;

    ~Node() { std::cout << "Node destroyed" << std::endl; }
};


int main() {
    std::shared_ptr<Node> n1(new Node());
    std::shared_ptr<Node> n2(new Node());

    n1->next = n2;
    n2->next = n1; // 这里会造成循环引用

    // 如果使用weak_ptr，解决循环引用
    std::weak_ptr<Node> wp = n1;
    std::shared_ptr<Node> sp = wp.lock(); // 检查弱指针是否有效

    return 0;
}

        在这段代码中，我们演示了如何使用 ‘weak_ptr‘ 解决循环引用问题。

RAII（资源获取即初始化）

        RAII（Resource Acquisition Is Initialization）是一种C++编程习惯，用于确保资源在对象生命周期内被正确地分配和释放。RAII的核心思想是将资源的分配和释放绑定到对象的生命周期。

RAII示例

        使用RAII模式可以确保文件在使用后自动关闭，例如：

#include <iostream>
#include <fstream>


class FileRAII {
public:
    FileRAII(const std::string& filename) : file(filename) {
        if (!file.is_open()) {
            throw std::runtime_error("Failed to open file");
        }
    }

    ~FileRAII() {
        if (file.is_open()) {
            file.close();
        }
    }
    std::ofstream& get() { return file; }

private:
    std::ofstream file;
};


int main() {
    try {
        FileRAII file("example.txt");
        
        file.get() << "Hello, RAII!" << std::endl;
    } 

    catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }

    return 0;
}

        在这段代码中，我们使用RAII模式管理文件对象，确保文件在使用后自动关闭。

总结

        内存管理是C++编程中的关键技能，通过合理的内存分配与释放、智能指针和RAII技术，可以极大地提高程序的健壮性和可维护性。C++11引入了一系列新工具，使内存管理变得更加简洁和安全。本篇博客详细介绍了动态内存分配与释放、智能指针（unique_ptr, shared_ptr, weak_ptr）以及RAII，希望通过这些内容，能更好地掌握C++中的内存管理技巧，为编写高效、可靠的C++程序打下坚实的基础。

下一篇：白骑士的C++教学高级篇 3.4 异常处理​​​​​​​