C++[第二十六章]--智能指针

智能指针

1、nullptr：初始化空指针

nullptr 是 nullptr_t 类型的右值常量，专用于初始化空类型指针

2、shared_ptr智能指针

和 unique_ptr、weak_ptr 不同之处在于，多个 shared_ptr 智能指针可以共同使用同一块堆内存。并且，由于该类型智能指针在实现上采用的是引用计数机制，即便有一个 shared_ptr 指针放弃了堆内存的“使用权”（引用计数减 1），也不会影响其他指向同一堆内存的 shared_ptr 指针（只有引用计数为 0 时，堆内存才会被自动释放）。

2.1shared_ptr智能指针的创建

1、创建空指针

std::shared_ptr<int> p1;             //不传入任何实参
std::shared_ptr<int> p2(nullptr);    //传入空指针 nullptr

2、构建 shared_ptr 智能指针，也可以明确其指向

std::shared_ptr<int> p3(new int(10));
std::shared_ptr<int> p3 = std::make_shared<int>(10);

3、shared_ptr 模板还提供有相应的拷贝构造函数和移动构造函数

//调用拷贝构造函数
std::shared_ptr<int> p4(p3);//或者 std::shared_ptr<int> p4 = p3;
//调用移动构造函数
std::shared_ptr<int> p5(std::move(p4)); //或者 std::shared_ptr<int> p5 = std::move(p4);

注意，同一普通指针不能同时为多个 shared_ptr 对象赋值，否则会导致程序发生异常。例如：

int* ptr = new int;
std::shared_ptr p1(ptr);
std::shared_ptr p2(ptr);//错误

4、在初始化 shared_ptr 智能指针时，还可以自定义所指堆内存的释放规则，这样当堆内存的引用计数为 0 时，会优先调用我们自定义的释放规则

//指定 default_delete 作为释放规则
//对于申请的动态数组来说，shared_ptr 指针默认的释放规则是不支持释放数组的，只能自定义对应的释放规则，才能正确地释放申请的堆内存
std::shared_ptr<int> p6(new int[10], std::default_delete<int[]>());

//自定义释放规则
void deleteInt(int*p) {
    delete []p;
}
//初始化智能指针，并自定义释放规则
std::shared_ptr<int> p7(new int[10], deleteInt);

2.2、shared_ptr模板类提供的成员方法

百度

注意：多个独立的shared_ptr指向同一块内存，多次释放，会发生内存泄漏问题。

2.3、make_shared的使用

make_shared是标准库函数，此函数在动态内存中分配一个对象并初始化它，返回指向此对象的shared_ptr。由于是通过shared_ptr管理内存，因此这是一种安全分配和使用动态内存的方法。

如：

shared_ptr<int> p3 = make_shared<int>(42);
p4指向一个值为"9999999999"的string
shared_ptr<string> p4 = make_shared<string>(10,'9');
shared_ptr<string> p2 = make_shared<string>("hello"); 
shared_ptr<int> p5 = make_shared<int>();
auto spw = std::make_shared<Widget>();

例子：

#include <iostream>
#include <memory>
using namespace std;

// void deleteInt(int*p) {

//     if(p)
//     {
//         delete p;
//     }
// }

#if 0
int main()
{
    int * a = new int(10);
    //构建 2 个智能指针
    //std::shared_ptr<int> p1(a,deleteInt);
    std::shared_ptr<int> p1(a);
    //std::shared_ptr<int> p2(p1);

	//std::shared_ptr<int> p3(a);  //多个独立的shared_ptr指向同一块内存，会发生内存泄漏问题

    //std::shared_ptr<int> p3(a,deleteInt);  //指定 default_delete 作为释放规则
    // //输出 p2 指向的数据
    // cout << *p2 << endl;
    // p1.reset();//引用计数减 1,p1为空指针
    // if (p1) {
    //     cout << "p1 不为空" << endl;
    // }
    // else {
    //     cout << "p1 为空" << endl;
    // }
    // //以上操作，并不会影响 p2
    // cout << *p2 << endl;
    //cout << *p3 << endl;
    //判断当前和 p2 同指向的智能指针有多少个
    cout << p1.use_count() << endl;
    return 0;
}

#endif

int main()
{
    int * a = new int(10);
    //构建 2 个智能指针
    std::unique_ptr<int> p1(a);
    //std::unique_ptr<int> p2(a);  //会释放两次
    std::unique_ptr<int> p2(std::move(p1));
    //std::unique_ptr<int> p2 = std::move(p1);

	//std::unique_ptr<int> p3(a);  /

    //std::unique_ptr<int> p3(a,deleteInt);  //指定 default_delete 作为释放规则

    //cout << *p1 << endl;
    cout << *p2 << endl;
    return 0;
}

2、unique_ptr

std::unique_ptr<int>p1(new int(5));
std::unique_ptr<int>p2=p1;// 编译会出错
std::unique_ptr<int>p3=std::move(p1);// 转移所有权, 现在那块内存归p3所有, p1成为无效的针.
p3.reset();//释放内存.
p1.reset();//无效

独享被管理对象指针所有权的智能指针

unique_ptr对象包装一个原始指针，并负责其生命周期。当该对象被销毁时，会在其析构函数中删除关联的原始指针。
unique_ptr具有->和*运算符重载符，因此它可以像普通指针一样使用。
注意：unique_ptr对象始终是关联的原始指针的唯一所有者。我们无法复制unique_ptr对象，它只能移动。