《C++ Primer 第五版中文版》第12章动态内存【阅读笔记 + 个人思考】

- 12.1 动态内存与智能指针
- - 12.1.1 shared_ptr类

静态内存包括：初始化只读数据段，初始化读写数据段，未初始化数据和常量数据段。

详细在下面博客总结：
Linux系统下C++程序运行时的内存布局及存储内容，生命周期，初始化时机详解。

智能指针的作用：一个动态内存空间对象应该被释放时，指向它的智能指针可以确保自动释放它。

12.1 动态内存与智能指针

运算符new：在动态内存为对象分配空间，返回指向该对象的指针。（是否进行初始化可选）

代码演示：当你使用new来分配内存但不提供初始化值时，分配的对象将拥有未定义的初始值（对于基本类型）。如果是类对象，将调用默认构造函数进行初始化。

#include <iostream>

int main() {
    // 为int分配内存，但不初始化，值未定义，访问这些未初始化的值是不安全的
    int* pInt = new int;

    // 为double分配内存，但不初始化，值未定义，访问这些未初始化的值是不安全的
    double* pDouble = new double;

    // 记得释放内存
    delete pInt;
    delete pDouble;

    return 0;
}

代码演示：使用new时，可以通过在类型后面添加圆括号()或大括号{}来提供初始化值。

#include <iostream>

int main() {
    // 为int分配内存，并初始化为0
    int* pInt = new int(0);

    // 为double分配内存，并初始化为0.0
    double* pDouble = new double(0.0);

    // 使用列表初始化
    int* pIntList = new int{10};
    double* pDoubleList = new double{10.5};

    std::cout << "*pInt: " << *pInt << "\n";
    std::cout << "*pDouble: " << *pDouble << "\n";
    std::cout << "*pIntList: " << *pIntList << "\n";
    std::cout << "*pDoubleList: " << *pDoubleList << "\n";

    // 记得释放内存
    delete pInt;
    delete pDouble;
    delete pIntList;
    delete pDoubleList;

    return 0;
}

运行结果：

详细值初始化和默认初始化参考：值初始化和默认初始化详解

delete：接受一个动态对象的指针，销毁该对象，释放与对象关联的内存空间。

内存泄露：没有释放内存。
引用非法内存的指针：有指针引用内存的情况下释放了内存空间。

（C++11）shared_ptr：共享所指对象。

（C++11）unique_ptr：独占所指对象。

（C++11）weak_ptr ：指向 shared_ptr 管理的对象。
参考：有了 unique_ptr 和 shared_ptr，要weak_ptr 有什么用？

头文件 memory。

12.1.1 shared_ptr类

智能指针是模板，默认初始化的智能指针中保存着一个空指针。

解引用智能指针：返回它指向的对象。

条件判断中使用智能指针：检测是否为空。

shared_ptr 和 unique_ptr 都支持的操作：![shared_ptr 和 unique_ptr
shared_ptr 独有的操作：

最安全的分配和使用动态内存的方法：调用 make_shared 标准库函数（分配对象并初始化，返回指向此对象的 shared_ptr。不传递任何参数，对象进行值初始化。定义在头文件 memory）。

代码演示：

#include <iostream>
#include <memory> // 包含std::shared_ptr及相关函数

class MyClass {
public:
    void classMethod() const {
        std::cout << "MyClass::classMethod() called" << std::endl;
    }
};

int main() {
    // 使用make_shared()方法创建std::shared_ptr
    std::shared_ptr<MyClass> sp1 = std::make_shared<MyClass>();

    // 判断shared_ptr是否为空
    if (sp1 != nullptr) {
        std::cout << "sp1 is not null" << std::endl;
    }

    // 解引用shared_ptr来调用对象的方法
    (*sp1).classMethod();

    // 使用->操作符调用对象成员函数
    sp1->classMethod();

    // 使用get()方法获取原始指针
    MyClass* p = sp1.get();
    std::cout << "Address of the object owned by sp1: " << p << std::endl;

    // 使用拷贝构造函数创建一个shared_ptr的副本
    std::shared_ptr<MyClass> sp2(sp1);
    std::cout << "use_count of sp1 after copying: " << sp1.use_count() << std::endl; // 输出引用计数

    // 使用赋值操作符
    std::shared_ptr<MyClass> sp3;
    sp3 = sp1;
    std::cout << "use_count of sp1 after assignment: " << sp1.use_count() << std::endl; // 输出引用计数

    // 使用unique()方法检查当前shared_ptr是否是对象唯一的所有者
    if (!sp1.unique()) {
        std::cout << "sp1 is not unique" << std::endl;
    }

    // 使用use_count()方法查看对象的引用计数
    std::cout << "use_count of sp1: " << sp1.use_count() << std::endl;

    // 使用swap()方法交换两个shared_ptr的内容
    std::shared_ptr<MyClass> sp4 = std::make_shared<MyClass>();
    std::cout << "Before swap, sp1 address: " << sp1.get() << ", sp4 address: " << sp4.get() << std::endl;
    sp1.swap(sp4);
    std::cout << "After swap, sp1 address: " << sp1.get() << ", sp4 address: " << sp4.get() << std::endl;

    // 当main()函数结束时, sp1, sp2, sp3, sp4将自动被析构，并且它们所拥有的对象也将被删除
    // 因为sp1, sp2, sp3指向同一个对象，所以只有当最后一个shared_ptr被销毁后对象才会被删除
    // sp4指向一个不同的对象，将独立于sp1, sp2, sp3进行析构

    return 0;
}