C++11新特性之智能指针

已于 2024-10-05 17:32:09 修改
阅读量1.1k 收藏 28
点赞数 18
分类专栏： C++ 文章标签： c++
于 2024-10-05 17:28:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_76953932/article/details/142716651
版权

目录

注意智能指针管理的是动态分配的内存，即堆区的数据

#include <memory>  // 智能指针的公用头文件

shared_ptr 共享

共享指针（是指可以多个 shared_ptr 指向同一块内存，进行管理）

好处：

  • 方便调用，重要的是防止内存泄漏
  • 因为我们自己定义指针，new 出空间，就得手动释放，但是智能指针是一个模板类，封装好了的，当不需要的时候，会在智能指针生命周期结束后自动释放内存
  • 比如定义在函数里，函数结束，它就结束，自动释放内存，还比如它不再指向内存空间了，就自动释放内存，指向空

初始化

默认构造函数

// shared_ptr<T> 类模板中，提供了多种实用的构造函数, 语法格式如下:
std::shared_ptr<T> 智能指针名字(创建堆内存);
shared_ptr<int> ptr1(new int(520));

std::make_shared

template< class T, class... Args >
shared_ptr<T> make_shared( Args&&... args );
shared_ptr<int> ptr1 = make_shared<int>(520);

class Person{
public:
    Person(string name, int age):m_name(name),m_age(age){}
    string m_name;
    int m_age;
};
shared_ptr<Person> ptr2 = make_shared<Person>("zhangsan", 1);
  • T：模板参数的数据类型
  • Args&&... args ：要初始化的数据，如果是通过 make_shared 创建对象，需按照构造函数的参数列表指定

reset

void reset() noexcept;

template<class T>
void reset(T* ptr);

template<class T, class Deleter>
void reset(T* ptr, Deleter d);

template<class T, class Deleter, class Alloc>
void reset(T* ptr, Deleter d, Alloc alloc);

ptr5.reset(new int(250));
  • ptr：指向要取得所有权的对象的指针
  • d：指定删除器，当不再使用这个共享指针的时候，就调用该删除器销毁对象
  • alloc：内部存储所用的分配器

==综合示例==

class Test {
public:
    Test() {}
    Test(int x) {
        cout << "construct Test, x = " << x << endl;
    }
    Test(string str) {
        cout << "construct Test, str = " << str << endl;
    }
    ~Test() {}
};

int main()
{
    shared_ptr<int> ptr1(new int(520));
    //调用拷贝构造函数
    shared_ptr<int> ptr2(ptr1);
    shared_ptr<int> ptr3 = ptr1;

    //调用移动构造函数
    shared_ptr<int> ptr4(std::move(ptr1));
    shared_ptr<int> ptr5 = std::move(ptr2);

    // make_shared 初始化
    shared_ptr<int> ptr6 = make_shared<int>(520);
    shared_ptr<Test> ptr7 = make_shared<Test>("zhangsan");
    shared_ptr<Test> ptr8 = make_shared<Test>(520);

    // reset 初始化
    ptr4.reset();     // 这样之后这个指针释放空间，不指向任何
    ptr5.reset(new int(250));	
    ptr8.reset(new int(250)); // 错误，类型不一致，一个为 Test 类，一个为 int
}

内部函数

// 管理当前对象的 shared_ptr 实例数量，或若无被管理对象则为 0。
long use_count() const noexcept;
ptr.use_count;  // 表示这个内存被多少个 shared_ptr 指针管理

// 获取原始指针（最开始的指针，指向空间的），也就是在智能指针管理之前的管理内存的指针
T* get() const noexcept;

shared_ptr<int> ptr1(new int(520));
int *p = ptr1.get();

Test *t = ptr.get();
t->setvalue(100);   // 假设 Test 类具有这个 setvalue
  • 上面 reset 和内部函数方法使用 . ，而这里使用 -> 本质是内部重载了这些符号，这是个类模板，这些方法是内部成员函数，使用 .
  • 而指针的使用是->，是为了方便我们把他就当成指针运算，方便记忆和使用，所以内部重载了->，使其和指针一样

注意点

int *a = new int(10);  
shared_ptr<int>ptr(a);  
*ptr = 100;  
cout << *a << endl;       // 输出 100
cout << ptr.use_count();  // 输出 1
  • 说明这个只是统计智能指针的数量，使用智能指针修改数据，实际也可改变，说明指针确实在管理内存

指定删除器

智能指针不指定删除器，会自动调用内部的删除器，将其内存释放，但也可指定

shared_ptr<int> ptr(new int(250), [](int *t){
    delete t;
});
// 这样直接结束后，调用析构函数，就会调用这个 lambda 构成的函数

但是数组不具有默认的删除器，因此需指定（C++11 不会，C++11 以后可以了）

shared_ptr<int> ptr(new int[10], [](int* p) {
    delete []p;
});
  • 同时，编译器也提供了删除器的模板函数
std::default_delete<T>();

shared_ptr<int> ptr(new int[10], default_delete<int []>());

unique_ptr 独占

只允许一个智能指针管理内存，但是不包括普通指针不能管理

初始化

unique_ptr<int> func() {
    return unique_ptr<int>(new int(520));
}

int main()
{
    // 通过构造函数初始化
    unique_ptr<int> ptr1(new int(10));
    // 通过转移所有权的方式初始化
    unique_ptr<int> ptr2 = std::move(ptr1);
    // 即将释放的独占智能指针
    unique_ptr<int> ptr3 = func();
    // reset
    ptr1.reset();
    ptr2.reset(new int(250));
}
// 同样支持 get 方法

注意

int main()  
{  
    int *a = new int(10);  
    unique_ptr<int>ptr(a);    // 这个定义是正确的
    *ptr = 100;  
    cout << *a << endl;     // 输出 100
}
// 说明普通指针也能指向，独占智能指针也在管理内存

指定删除器

语法和共享的类似

展示区别

shared_ptr<int> ptr1(new int(10), [](int*p) {delete p; });	// 正确
unique_ptr<int> ptr1(new int(10), [](int*p) {delete p; });	// 错误

int main()
{
    // 这样才正确，需要指定删除器函数类型，这里就是函数指针类型
    using func_ptr = void(*)(int*);
    unique_ptr<int, func_ptr> ptr1(new int(10), [](int*p) {delete p; });
}
  • 如果上述的 lambda 表达式中 [] 里面传参数，就又不对了，捕捉了外部变量，此时 lambda 就不能看作是函数指针了，此时是一个仿函数
  • lambda 作为仿函数类型 我们不方便指定其类型
  • 使用包装器解决或者不使用 lambda 表达式，就使用一个函数，然后就能指定类型
void deleteInt(int* p) { 
    delete p; 
}

int main()
{
    // 错误演示
    using func_ptr = void(*)(int*);
    unique_ptr<int, func_ptr> ptr1(new int(10), [=](int*p) {delete p; });
    
    // 正确，使用包装器解决
    unique_ptr<int, function<void(int*)>> ptr1(new int(10), [&](int*p) {delete p; });
    // 正确，使用定义的函数解决
    using func_ptr = void(*)(int*);
    unique_ptr<int, func_ptr> ptr1(new int(10), deleteInt); 
}
// 对捕捉变量后的 lambda 表达式不是函数指针疑惑的，详情见 lambda 表达式章节

// 独占的 C++11 就支持对数组调用默认删除器
// 而共享的 C++11 后支持
unique_ptr<int[]> ptr(new int [3]);

weak_ptr 弱引用

它不共享指针，不能操作资源，是用来监视 shared_ptr 的

  • 弱引用智能指针 std::weak_ptr 可以看做是 shared_ptr 的助手，它不管理 shared_ptr 内部的指针
  • std::weak_ptr 没有重载操作符 * 和 ->，因为它不共享指针，不能操作资源，所以它的构造不会增加引用计数（指向当前内存空间的智能指针数量），析构也不会减少引用计数，它的主要作用就是作为一个旁观者监视 shared_ptr 中管理的资源是否存在

初始化

语法：

// 默认构造函数
constexpr weak_ptr() noexcept;
// 拷贝构造
weak_ptr (const weak_ptr& x) noexcept;
template <class T> weak_ptr (const weak_ptr<T>& x) noexcept;
// 通过shared_ptr对象构造
template <class T> weak_ptr (const shared_ptr<T>& x) noexcept;

shared_ptr<int> sp(new int (10));

weak_ptr<int> wp1 = new int (11);    // 错误，需要在 shared_ptr 基础上创建，监视作用
weak_ptr<int> wp2(sp);
weak_ptr<int> wp3(wp2);
weak_ptr<int> wp4 = sp;
weak_ptr<int> wp5 = wp3;

内部函数

use_count()

// 函数返回所监测的资源的引用计数
long int use_count() const noexcept;

weak_ptr 只是监测资源，并不管理资源，所以不会导致计数加一

expired()

// 返回 true 表示 shared_ptr 指向的资源已经被释放, 返回 false 表示资源没有被释放
bool expired() const noexcept;

示例

shared_ptr<int> shared(new int(10));
weak_ptr<int> weak(shared);
cout << "1. weak " << (weak.expired() ? "is" : "is not") << " expired" << endl;

shared.reset();
cout << "2. weak " << (weak.expired() ? "is" : "is not") << " expired" << endl;

执行结果：

1. weak is not expired
2. weak is expired

lock()

// 获取所监测资源的 shared_ptr 对象
shared_ptr<element_type> lock() const noexcept;

reset()

// 清空对象，使其不检测任何资源
void reset() noexcept;

解决 shared_ptr 遗留的问题

不能使用一个原始地址初始化多个共享智能指针

struct Test {  
    Test(){};  
    ~Test() {  
        cout << "class Test is disstruct ..." << endl;  
    }  
};  
  
int main()  
{  
    Test *t = new Test;  
    shared_ptr<Test> ptr1(t);  
    cout << "use_count: " << ptr1.use_count() << endl;  
    shared_ptr<Test> ptr2(t);  
    cout << "use_count: " << ptr2.use_count() << endl;  
    return 0;  
}

执行结果：

use_count: 1
use_count: 1
析构了
析构了
  • 调用了两次析构，一个是 ptr1 ，一个是 ptr2
  • 这就有问题，一块空间释放了两次
  • 这里的错误是使用了原始地址 t 去初始化了多个共享智能指针，正确写法是 shared_ptr<Test> ptr2(ptr1);
  • 还有人可能疑惑第一行 Test *t = new Test 为啥没有析构函数调用
Test *t = new Test;  
delete t;        
// 因为是创建在堆区，需要手动释放，写 delete 就会调用析构函数

Test t; 
// 这样写，生命周期结束后就会自动调用析构函数

函数不能返回管理了 this 的共享智能指针

需求是通过成员函数返回管理当前对象的共享智能指针

  • 错误实现
struct Test {
    shared_ptr<Test> getSharedPtr() {
        return shared_ptr<Test>(this);
    }
    
    ~Test() {
        cout << "析构函数调用" << endl;
    }
};

int main() 
{
    shared_ptr<Test> ptr1(new Test);
    cout << "use_count: " << ptr1.use_count() << endl;
    shared_ptr<Test> ptr2 = ptr1->getSharedPtr();
    cout << "use_count: " << ptr2.use_count() << endl;
    return 0;
}

use_count: 1
use_count: 1
析构函数调用
析构函数调用
  • 这本质和上面那个 错误一致，都是使用了原始地址初始化了两次智能指针，导致出错
  • 因为返回 shared_ptr ，在成员函数里使用的是 this 初始化 shared_ptr，再赋值给 ptr2，而 this 就是 ptr1 初始化的 new Test，所以就导致 new Test 的地址分配给 ptr1 和 ptr2
  • 就和第一个一样的问题了

解决方案就是通过 weak_ptr 来解决，通过 wek_ptr 返回管理 this 资源的共享智能指针对象 shared_ptr

std::enable_shared_from_this<T>   // 模板类
shared_from_this()   // 所调用的成员方法
  • 它的本质实现是使用了 weak_ptr 里的 lock() 方法实现，返回 shared_ptr
struct Test : public enable_shared_from_this<Test> {
    shared_ptr<Test> getSharedPtr() {
        return shared_from_this();
    }
    
    ~Test() {
        cout << "析构函数调用" << endl;
    }
};

int main() 
{
    shared_ptr<Test> ptr1(new Test);
    cout << "use_count: " << ptr1.use_count() << endl;
    shared_ptr<Test> ptr2 = ptr1->getSharedPtr();
    cout << "use_count: " << ptr2.use_count() << endl;
    return 0;
}

执行结果：

use_count: 1
use_count: 2
析构函数调用
  • 在调用 enable_shared_from_this 类的 shared_from_this () 方法之前，必须要先初始化函数内部 weak_ptr 对象，否则该函数无法返回一个有效的 shared_ptr 对象

weak_ptr 是如何隐式创建的？

  • 当你使用 shared_ptr 创建对象并且该对象的类继承了 enable_shared_from_this，在对象创建时，enable_shared_from_this 内部会生成一个指向该对象的 weak_ptr。这个 weak_ptr 用来跟踪当前对象，确保 shared_from_this() 返回的 shared_ptr 是安全的。

解决循环引用问题

struct TA;
struct TB;

struct TA {
    shared_ptr<TB> bptr;
    ~TA() {
        cout << "class TA is disstruct ..." << endl;
    }
};

struct TB {
    shared_ptr<TA> aptr;
    ~TB() {
        cout << "class TB is disstruct ..." << endl;
    }
};

void testPtr()
{
    shared_ptr<TA> ap(new TA);
    shared_ptr<TB> bp(new TB);
    cout << "TA1 use_count: " << ap.use_count() << endl;
    cout << "TB1 use_count: " << bp.use_count() << endl;

    ap->bptr = bp;
    bp->aptr = ap;
    cout << "TA2 use_count: " << ap.use_count() << endl;
    cout << "TB2 use_count: " << bp.use_count() << endl;
}

int main() {
    testPtr();
}

TA1 use_count: 1
TB1 use_count: 1
TA2 use_count: 2
TB2 use_count: 2
  • 会发现没有析构函数的调用，但正确的应该有两个
  • 这个原因是循环了，最终的计数都为 2，但是当 testPtr() 函数执行完后，ap，bp 对象生命周期结束，那么它们所指向的内存空间智能指针计数都减一，最终空间计数都为 1
  • 此时不会析构，因为智能指针析构的判断依据是当前的内存空间指针指针计数为 0，此时就会发生内存泄漏

解决办法就是让类里面的其中一个 shared_ptr 定义为 weak_ptr，这样就打破了环的局面

记住 weak_ptr 不会让智能指针计数增加

struct TA {
    weak_ptr<TB> bptr;
    ~TA() {
        cout << "class TA is disstruct ..." << endl;
    }
};
....  // 其余代码和上面一样

TA1 use_count: 1
TB1 use_count: 1
TA2 use_count: 2
TB2 use_count: 1
class TB is disstruct ...
class TA is disstruct ...

分析这个如何打破的

  • weak_ptr 不会让智能指针计数增加，所以最终结果就是执行结果所示
  • 当 testPtr() 函数执行完毕，ap，bp 对象生命周期结束，对应的内存空间计数减一，此时 bp 所指向的空间智能指针计数为 0，所以那块空间被释放，调用了析构函数，所以输出了 class TB is disstruct ...
  • 由于 TB 被析构，那么内部成员 aptr 也被析构，那么所指向的 TA 的空间的智能指针计数再减一，此时为 0，就调用了 TA 的析构函数，空间释放，输出 class TA is disstruct ...

可能还有小伙伴考虑为啥不直接删除其中一个 shared_ptr 成员变量，我也考虑到了，hh 还没想明白，但是需要知道 shared_ptr 是有循环引用风险的这里需注意，weak_ptr 是可以打破的 然后还能作为旁观者，应该是有它妙处的，以后遇到就明白了，不深究了

说明：本文是在 https://subingwen.cn/ 学习过程中的总结

星竹
关注
专栏目录
【C++11新特性】详解智能指针 创建、使用、注意事项
努力让自己的能力配得上梦想.
02-18 1773
C++11 中引入了智能指针，便于进行内存管理 使用智能指针 需要包含头文件：#include 以及 std 命名空间 智能指针会自动回收空间，不需要担心内存泄漏问题 四种智能指针： auto_ptr（C++11 被弃用） unique_ptr shared_ptr weak_ptr 一、 auto_ptr 创建auto_ptr对象的三种方式：
C++11新特性之智能指针源码详解
jyd185348578的博客
07-05 887
智能指针的核心思想就是将要在堆内存中创建的对象放到栈中来进行管理，具体做法就是使用模板类封装指针，在类中分配内存，析构函数中释放内存，这个模板对象建立在栈中，当作用域结束自动调用该对象的析构函数。unique中没有拷贝构造和赋值构造，只有构造初始化shared只有第一个使用构造初始化，其他的shared对这个对象使用拷贝构造和赋值构造实现多个指针指向同一块的地址和统计个数，每个对象析构的时候计数减1，直到为0才会释放那块内存weak。
c++11新特性——智能指针详解
weixin_46935110的博客
07-24 1481
c++11新特性——智能指针详解
20170911_C++11新特性之智能指针
风暴计划
09-11 418
20170911_C++11新特性之智能指针
C++11新特性（智能指针详细介绍）
m0_60416282的博客
07-21 2368
什么是内存泄漏？ 智能指针auto_ptr、unique_ptr、shared_ptr、weak_ptr
c++11新特性-智能指针
SuperYang_的博客
09-01 1265
智能指针RAII(Resource Acquisition Is Initialization)，是一种利用对象的生命周期来管理资源的技术。如果我们采用传统的new/delete来申请和释放资源，如果忘记调用delete，或者在调用delete之前程序抛出异常，都会导致内存泄漏问题，如代码1.1，Func函数中的new p2和Div都可能抛异常，导致后面的delete没有执行从而引发内存泄漏，采用智能指针对资源进行管理，能够杜绝这类问题。代码1.1：因异常引发的内存泄漏throw "除0错误";
C++11特性-智能指针
weixin_44840658的博客
12-05 730
C11的shared_ptr、weak_ptr、unique_ptr的介绍
C++11新增特性：智能指针（RAII）
Zhenyu_Coder的博客
09-22 1441
在C++的发展史中，一个出现了4种智能指针，依次为auto_ptr、unique_ptr、shared_ptr、weak_ptr（weak_ptr不符合RAII思想，用于对shared_ptr的补贴）同理，n1的引用计数也更新为2！但是_next属于n2的成员，n1释放了，_next才会析构，而n2由_prev管理，_prev属于n1成员，此时就发生了循环引用，谁也不会释放。weak_ptr不符合RAII，不参与引用计数，仅是对 shared_ptr 所管理对象的一个非拥有性引用，但可以像指针一样使用！
C++ 智能指针 - 全部用法详解
热门推荐
cpp_learner的博客
08-02 8万+
血的教训？不学智能指针，本人丢了一份工作。
C++11新特性之智能指针(shared_ptr/unique_ptr/weak_ptr)
09-01
C++11引入了智能指针作为现代C++编程的重要特性，极大地改善了内存管理的复杂性。智能指针是具有自动内存管理功能的对象，它们在适当的时候自动释放所指向的对象，防止内存泄漏。本文主要讨论了三种智能指针：`...
杨辉三角——c语言
最新发布
aqua3535742358的博客
11-05 533
define N 10 //自己定义输出行数。
Type-C PD诱骗取电快充协议芯片 支持PD 5V、9V、12V、15V、20V电压
xcx003的博客
11-02 603
XSP01A是一款专为Type-C接口设计的取电诱骗协议芯片，它它集成了先进的电源管理和协议控制功能，旨在为用户提供高效、安全、稳定的充电体验。该芯片集成USB Power Delivery (PD) 3.0/2.0快充协议，支持从手机充电器/车充等电源上取电给产品供电。支持最大功率100W给设备安全快速供电。综上所述，XSP01A诱骗取电协议芯片以其高效、安全、稳定的充电性能以及广泛的设备兼容性和应用场景，正在逐步改变着我们的充电体验和设备电源管理方式。
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 303
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
C++编程法则365天一天一条（344）理解std::optional的设计初衷
二进制君
11-02 95
的设计初衷是为了解决处理可选值时的安全性和清晰性问题，提供一种简洁、易用的方式来表示和管理可能不存在的值。通过引入，C++ 提供了一个更现代化的替代方案，减少了使用传统空指针和特定标记值所带来的复杂性和错误风险。
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
weixin_66461496的博客
11-02 1024
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
每日OJ题_牛客_排序子序列_模拟_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-02 363
每日OJ题_牛客_排序子序列_模拟_C++_Java（根据题意用指针模拟即可）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值