C++基础之智能指针

最新推荐文章于 2024-06-05 11:19:38 发布
最新推荐文章于 2024-06-05 11:19:38 发布
阅读量1.2k 收藏 2
点赞数
分类专栏： C/C++ 文章标签： c++ 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QQ1COM12345/article/details/121549188
版权

文章目录

前言

C++程序设计中会频繁的操作堆内存，堆内存的申请和释放都是由程序员自己管理，使用普通指针，容易造成内存泄露，二次释放等问题，使用智能指针能更好的管理堆内存。

提示：以下是本篇文章正文内容

一、智能指针有哪些

C++里面有四个智能指针，auto_ptr, unique_ptr, shared_ptr, weak_ptr。其中后三个是C++11支持，并且第一个auto_ptr已经被c++11弃用。

二、shared_ptr

1.特性

  1. 每一个shared_ptr的拷贝都指向相同的内存。
  2. shared_ptr使用引用计数机制，每当shared_ptr被拷贝时，引用计数会自动加1，每析构一个shared_ptr，引用计数会减1，当引用计数为0，也就是最后一个shared_ptr被析构的时候，shared_ptr指向的内存才会被释放。

简单来说，shared_ptr实现包含了两个部分：一个指向堆上创建的对象的裸指针：raw_ptr；一个指向内部隐藏的，共享的管理对象：share_count_object。这部分也就是当前这个堆对象被多少个shared_ptr引用了，简单来说就是引用计数。

2.初始化

可以通过构造函数、std::shared_ptr辅助函数和reset方法来初始化shared_ptr。
代码如下：

std::shared_ptr<int> p1(new int(1));
std::shared_ptr<int> p2 = p1;
std::shared_ptr<int> p3;
p3.reset(new int(2));

if(p3) {
    std::cout << "p3 is not null" << std::endl;
}

注意要包含头文件 #include < memory >

也可以使用make_shared来构造智能指针（优先）
代码如下：

auto sp1 = std::make_shared<int>(100);
if(sp1)
{
    std::cout << "sp1 is not null \n";
}

不能通过原始指针直接赋值给一个智能指针

std::shared_ptr<int> p = new int(1);  //invalid
//编译报错：error: conversion from ‘int*’ to non-scalar type ‘std::shared_ptr<int>’ requested

3.关于shared_ptr的成员函数reset

  1. 调用p.reset()，不带参数，则表明释放该智能指针p指向的空间（也就是引用计数-1），并不指向新的内存空间。
  2. 若调用p.reset(q)，说明将p的内置指针换位q，然后调用默认删除器delete释放p之前所指的空间。
  3. 若调用p.reset(q,d)，与2相同，但是不是使用默认删除器，而是使用指定的删除器d来释放之前所指的空间 。
  4. 若调用p.reset(q,d,a)，第三个参数值指定构造器。

参考文档:cppreference

4.引用计数的例子

代码如下：

std::shared_ptr<int> p1;
p1.reset(new int(1));
std::shared_ptr<int> p2 = p1;

//use_count() == 2
std::cout << "p2.user_count() = " << p2.use_count() << std::endl;

p1.reset();
std::cout << "p1.reset() \n";

//use_count() == 1
std::cout << "p2.user_count() = " << p2.use_count() << std::endl;

if(!p1) {
    std::cout << "p1 is empty\n";
}
if(!p2) {
    std::cout << "p2 is empty\n";
}

p2.reset();
std::cout << "p2 reset()\n";
//use_count() == 0
std::cout << "p2.user_count() = " << p2.use_count() << std::endl;

if(!p2) {
    std::cout << "p2 is empty\n";
}

打印
在这里插入图片描述

5.获取原始指针

std::shared_ptr<int> ptr(new int(8));
int *p = ptr.get();

虽然给出了获取原始指针的接口，但是最好不要去调用它，因为这可能充满着为止的危险。这里有几个约定：

  1. 不要保存get()返回的裸指针。无论是保存为裸指针还是智能指针，都有可能让其变成空悬指针和独立指针的危险。
  2. 不要delete get()返回的指针，这有可能会引发double free的错误。

6.构造时指定删除器

void DeleteIntPtr(int *p)
{
    std::cout << "call delete int ptr function \n";
    delete p;
}

int main()
{
	//指定删除器
    std::shared_ptr<int> p(new int(1), DeleteIntPtr);
    //通过lambda表达式
    std::shared_ptr<int> p1(new int(1), [](int *p){
        std::cout << "call lambda delete p \n";
        delete p;
    });

    /*
    * 智能指针在栈上，后申请的先释放？？？
    *   call lambda delete p 
    *   call delete int ptr function
    */

   p.reset();
   p1.reset();

   /*
   *
   *    call delete int ptr function 
   *    call lambda delete p 
   */

    //shared_ptr默认删除器不支持数组对象，需要自己指定删除器
    std::shared_ptr<int> p(new int[10], [](int *p){
        delete[] p;
    });
}

7.注意事项

class A
{
    public:
    std::shared_ptr<A> GetSelf()
    {
        return std::shared_ptr<A>(this);
    }
    ~A()
    {
        std::cout << "Deconstruction A" <<  std::endl;
    }
};

class B:public std::enable_shared_from_this<B>
{
    public:
    std::shared_ptr<B> GetSelf()
    {
        return shared_from_this();
    }
    ~B()
    {
        std::cout << "Deconstruction B" <<  std::endl;
    }
};

class C;
class D;

class C
{
    public:
    std::shared_ptr<D>  dptr;
    ~C() {
        std::cout << "C is deleted" << std::endl;
    }
};

class D
{
    public:
    std::shared_ptr<C>  cptr;
    ~D() {
        std::cout << "D is deleted" << std::endl;
    }
};

//1.不要用一个原始指针初始化多个shared_ptr. 会引发double free
int *ptr = new int;
std::shared_ptr<int> p1(ptr);
std::shared_ptr<int> p2(ptr);
//打印：
//free(): double free detected in tcache 2

//2.不要在函数实参中创建shared_ptr
function(shared_ptr<int>(new int), g());
//对于函数参数的计算顺序在不同编译器不同的约定下可能是不一样的，一般是从右到左，但也可能从左到右
//所以，可能先new int， 然后在调用g(),如果g()发生异常，而shared_ptr还没有创建，则int内存泄露了，应该先创建智能指针，
shared_ptr<int> p(new int);
function(p, g());

//3.通过shared_from_this()返回this指针，不要将this指针作为shared_ptr返回出来，因为this指针本质上是一个裸指针，因此可能会导致重复析构
std::shared_ptr<A> sp1(new A);
std::shared_ptr<A> sp2 = sp1->GetSelf();
//打印：
//Deconstruction A
//Deconstruction A
//free(): double free detected in tcache 2

//正确的做法：让目标类通过继承std::enable_shared_from_this类，然后通过父类的成员函数shared_from_this()来返回this的shared_ptr
std::shared_ptr<B> sp1(new B);
std::shared_ptr<B> sp2 = sp1->GetSelf();
//打印：
//Deconstruction B
//析构一次，不会发生double free的错误。

//避免循环引用  
{
    std::shared_ptr<C> cp(new C);
    std::shared_ptr<D> dp(new D);
    cp->dptr = dp;
    dp->cptr = cp;
    std::cout << "cp.user_count() = " << cp.use_count() << std::endl; //2
    std::cout << "dp.user_count() = " << dp.use_count() << std::endl; //2
}
std::cout << "main leave \n"; 
//循环引用导致cp dp退出了作用域，引用计数器减为1，并没有减为0，所以都没有析构。
//解决办法是把A和B的任何一个成员变量改为weak_ptr。

三、unique_ptr

1.特性

  1. 独占式智能指针
  2. 不能做赋值操作
  3. 可以通过move转移

2.初始化

std::unique_ptr<int> p(new int);
//std::unique_ptr<int> p1 = p;   //报错，不允许复制。
std::unique_ptr<int> p1 = std::move(p); //正确，p对指针的所有权转移给p1,所以p为空了。
if(!p) {
    std::cout << "p is empty\n";   //打印这一句，因为通过move把p指向的内存空间和引用计数转移给了p1,并释放了p的资源。
}
if(!p1) {
    std::cout << "p1 is empty\n";  //不会打印这一句
}

c++14引入了make_unique来初始化一个unique_ptr指针

auto p = std::make_unique<int>(10);

3.shared_ptr 和unique_ptr的区别

  1. 在C++17之前，不能使用unique_ptr指向一个数组，但是C++17之后是可以的。
//shared_ptr 和 unique_ptr的区别
//1.数组  测试可以！！难道那个标准把这个加入 了？？ c++17
std::unique_ptr<int []> p(new int[10]);
p[9] = 9;
std::shared_ptr<int []> p2(new int[10]);
p2[9] = 9;
  1. 删除器
std::shared_ptr<int> ptr(new int(1), [](int *p){delete  p;}); //valid
// std::unique_ptr<int> ptr1(new int(1), [](int *p){delete  p;}); //invalid
std::unique_ptr<int, void(*)(int*)> ptr2(new int(1), [](int *p){delete p;}); //vaild
//第二句会出现编译错误
//error: no matching function for call to ‘std::unique_ptr<int>::unique_ptr(int*, main()::<lambda(int*)>)’

四、weak_ptr

1.特性

  1. 弱引用，不控制对象的生命周期，主要是解决shared_ptr出现的循环引用的问题。如下面的代码：
class A;
class B;

class A
{
    public:
    std::weak_ptr<B>  bptr;
    ~A()
    {
        std::cout << "Deconstruction A" <<  std::endl;
    }
};

class B
{
    public:
   	std::shared_ptr<A>  aptr;
    ~B()
    {
        std::cout << "Deconstruction B" <<  std::endl;
    }
};

int main()
{
	{
        std::shared_ptr<A> ap(new A);
        std::shared_ptr<B> bp(new B);
        bp->aptr = ap;
        ap->bptr = bp;
    }
    std::cout << "main leave \n";
}

代码解析：由于bptr是weak_ptr，当执行ap->bptr=bp的时候，它并不会增加引用计数，所以bp的引用计数还是为1，当离开作用域之后，bp的引用计数减为0，B的指针会被析构，析构之后ap的引用计数减为1，当离开作用域的时候ap的引用计数减为0，然后A也被析构。不会发生内存泄露的问题。

  1. weak_ptr没有重载*和->运算符，因为它不共享指针，不能操作资源。
  2. weak_ptr纯粹作为一个旁观者来监视shared_ptr中管理的资源是否存在。
  3. weak_ptr使用lock函数来获得shared_ptr的智能指针。
  4. weak_ptr可以返回this指针。解决double free的问题，如下面代码：
class B:public std::enable_shared_from_this<B>
{
    public:
    std::shared_ptr<B> GetSelf()
    {
        return shared_from_this();
    }
    ~B()
    {
        std::cout << "Deconstruction B" <<  std::endl;
    }
};

代码解析：通过派生
std::enable_shared_from_this类，并通过其方法shared_from_this来返回指针，原因是
std::enable_shared_from_this类中有一个weak_ptr，这个weak_ptr用来观察this智能指针，调用
shared_from_this()方法是，会调用内部这个weak_ptr的lock()方法，将所观察的shared_ptr返回。

2.基本用法

  1. 使用user_count()获取当前观察资源的引用计数
std::shared_ptr<int> sp(new int(10));
std::weak_ptr<int> wp(sp); 
std::cout << wp.use_count() << std::endl; //结果讲输出1
  1. 使用expired()方法判断所观察资源是否已经释放
std::shared_ptr<int> sp(new int(10)); 
std::weak_ptr<int> wp(sp); 
if(wp.expired()) 
	std::cout << "weak_ptr无效,资源已释放"; 
else
	std::cout << "weak_ptr有效";
  1. 使用lock()方法获取监视的shared_ptr
std::weak_ptr<int> gw;

void f()
{
    if(gw.expired())
    {
        std::cout << "gw 资源已经被释放\n";
    }else{
        auto spt = gw.lock();
        std::cout << "gw有效, *spt = " << *spt << std::endl;
    }
}

int main()
{
	{
      auto sp = std::shared_ptr<int>(new int(42));
       gw  = sp;
       f();
   }
   f();
}

打印：
在这里插入图片描述

3.weak_ptr使用注意事项

第一段代码：

std::weak_ptr<int> wp;
{
    std::shared_ptr<int> sp(new int(1));
    std::cout << "sp.user_count() = " << sp.use_count() << std::endl; //1
    wp = sp;
    std::cout << "sp.user_count() = " << sp.use_count() << std::endl; //1
    std::cout << "wp.user_count() = " << wp.use_count() << std::endl; //1
    std::shared_ptr<int> sp_ok = wp.lock();
    std::cout << "sp_ok.user_count() = " << sp_ok.use_count() << std::endl; //2
    std::cout << "wp.user_count() = " << wp.use_count() << std::endl; //2
}
std::cout << "wp.user_count() = " << wp.use_count() << std::endl; //0
if(wp.expired()) 
{ 
    std::cout << "shared_ptr is destroy" << std::endl; 
} else { 
    std::cout << "shared_ptr no destroy" << std::endl; 
}
std::shared_ptr<int> sp_null = wp.lock();

打印输出：
在这里插入图片描述

代码解析：
sp和sp_ok在离开作用域后，引用计数减为0，指向的资源被释放，所以最后通过弱引用只能指针wp打印观察的sp的user_count()计数为0，sp被销毁，所以在使用wp前需要调用wp.expired()函数判断一下。

第二段代码：

std::weak_ptr<int> wp;
std::shared_ptr<int> sp_ok;
{
    std::shared_ptr<int> sp(new int(1));
    std::cout << "sp.user_count() = " << sp.use_count() << std::endl; //1
    wp = sp;
    std::cout << "sp.user_count() = " << sp.use_count() << std::endl; //1
    std::cout << "wp.user_count() = " << wp.use_count() << std::endl; //1
    sp_ok = wp.lock();
    std::cout << "sp_ok.user_count() = " << sp_ok.use_count() << std::endl; //2
    std::cout << "wp.user_count() = " << wp.use_count() << std::endl; //2
}
std::cout << "sp_ok.user_count() = " << sp_ok.use_count() << std::endl; //1
std::cout << "wp.user_count() = " << wp.use_count() << std::endl; //1 
if(wp.expired()) 
{ 
    std::cout << "shared_ptr is destroy" << std::endl; 
} else { 
    std::cout << "shared_ptr no destroy" << std::endl; 
}

打印输出：
在这里插入图片描述
代码解析：
sp离开了作用域，引用计数减1，但是sp_ok尚未离开其作用域 ，所以wp最后打印的user_count()为1，智能指针sp尚未被销毁。

五、智能指针安全性问题

在多线程环境下：

  1. 引用计数本事是安全的。
  2. 多线程操作同一个shared_ptr对象是不安全的。（引用传递或者指针传递）
  3. 多线程操作不同的shared_ptr，但是指向同一个资源，是安全的。（按值传递）
  4. 多线程的各自的sp管理者同一个资源对象A，需要A自己保证多线程安全。

参考：智能指针的线程安全

秃头胖胖怪
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ROS | LIO-SAM编译失败no matching function for call to ‘PreintegratedImuMeasurements()‘
九七的博客
08-04 790
LIO-SAM编译失败no matching function for call to ‘PreintegratedImuMeasurements()‘
C++基础教程之指针拷贝详解
08-31
在C++编程中，指针拷贝是一个非常重要的概念，特别是在涉及到对象的构造...在实际开发中，通常推荐使用智能指针（如 `std::unique_ptr` 或 `std::shared_ptr`）来自动管理内存，以减少手动内存管理的负担和出错的风险。
error: conversion to non-scalar type requested。请求转换为非标量类型
qq_40397392的博客
06-03 4543
的变量，比如struct类型、类，这些都有成员变量，是可再细分的。的变量，比如指针变量、int变量等。什么是标量， 什么是非标量？
LIO-SAM报错记录
最新发布
lysine_的博客
06-05 332
【代码】LIO-SAM报错记录。
LVI-SAM遇到的错误
qq_62216048的博客
01-29 917
关于运行LVI-SAM上遇到的问题
20.04ubantu 编译lio_sam问题解决
m0_46398174的博客
07-17 951
因此我修改了cmake.txt来改变整个问题，但是不推荐这种方法，因为还要去修改msg的头文件问题，比较麻烦．附上修改后。这个就是链接问题，ros环境中有pcl1.10而我安装了pcl1.13，在链接时候出错误。主要问题为编译顺序中的问题调整前面。1.opencv与flann冲突。大部分基础问题这篇就能解决．。到include末尾就行了．。
error: conversion from 'std::_List_const_iterator<_Mylist>' to non-scalar type 'std::_List_iterator<
绯浅yousa的笔记
09-22 4098
error: conversion from ‘std::_List_const_iterator<_Mylist>’ to non-scalar type ‘std::_List_iterator<_Mylist>’ requested解决error C2440: “初始化”: 无法从“std::_List_const_iterator<_Mylist>”转换为“std::_List_iterat
c++智能指针的实现
07-02
智能指针是用来实现指针指向的对象的共享的。其实现的基本思想： 每次创建类的新对象时，初始化指针并将引用计数置为1； 当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数； 对一个...
C++线程安全问题及解决方法，C++智能指针
11-30
对于C++智能指针作出了简要介绍。同时整理了相关的例子帮助理解。适用人群：有一定的编程基础，工作1-3年的研发人员。能学到什么：了解C++线程安全问题的原因，以及掌握解决线程安全问题的方法。同时能够掌握一下锁...
C++智能指针实现
01-14
智能指针是存储指向动态分配（堆）对象指针的类, 用于生存期控制, 能够确保自动正确的销毁动态分配的对象，防止内存泄露。它的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的...
c++ “指针”学习建议
06-08
- C++11引入了智能指针如`std::unique_ptr`、`std::shared_ptr`和`std::weak_ptr`，它们在不再需要时自动管理内存，降低了内存泄漏的风险。 7. **指针和数组**： - 在C++中，数组名实际上是一个指向数组首元素的...
PCL报错集——error 2664 无法将参数 1 从“std::shared_ptr”转换为“const boost::shared_ptr＜const pcl::PointRepresentat
qq_39139736的博客
05-22 1913
PCL报错集——error 2664 无法将参数 1 从“std::shared_ptr”转换为“const boost::shared_ptr<const pcl::PointRepresentat 在用PCL1.8跑连续多幅点云配准的代码时。 在配准函数的非线性ICP代码中 存在报错： // 配准 pcl::IterativeClosestPointNonLinear<PointNormalT, PointNormalT> reg; // 非线性LM-ICP配准 reg.set
WebView的使用
Langxingtianxi的专栏
03-12 537
webView= (WebView) findViewById(R.id.webview); titleTV= (TextView) findViewById(R.id.title); iconIV= (ImageView) findViewById(R.id.icon); webView.loadUrl(url); WebSetti
shared_ptr的几个思考
yudelian的博客
10-23 724
1、因为涉及到C++转换C接口，就想着能不能简单点，把shared_ptr转换为void *作为一个handle 结果证明：编译错误 test_shared_ptr.cc: In function ‘void convert_shared_ptr_to_void()’: test_shared_ptr.cc:26:14: error: cannot convert ‘std::shared_ptr<Test>’ to ‘void*’ in initializati...
C++编程报错总结2023/6/17
weixin_56337147的博客
06-17 487
这里假设您已经定义了 `Transform` 对象 `extr`、`start_pose` 和 `end_pose`，并且已经创建了 `org_pc` 和 `comp_pc` 对象并加载了点云数据。根据您提供的信息，变换 `start_pose` 是由一个四元数和一个平移向量构成的，其中四元数的系数为 `tk_q_w, tk_q_x, tk_q_y, tk_q_z`，平移向量的系数为 `tk_p_x, tk_p_y, tk_p_z`。`->` 操作符通常用于指向类对象的指针上，以访问该类的成员。
pcl点云库运行错误 boost智能指针出错
bBoy_Stte的博客
12-15 2097
C2439“boost::shared_ptr<pcl::PointCloud>::px 未能初始化成员 在执行区域生长算法之前的法线提取步骤中，用于存储法线提取结果的OutputPointCloud实例化出错，pcl::Norma写成pcl::PointXYZ（出错在第47行），此类错误一般就是boost智能指针初始化出现了问题。 注：本人为pcl入门级小白(是真的很“白”)，由于...
std::shared_ptr作为函数形参，通过值传递、引用传递的问题解答
langxm2006的专栏
09-23 2899
，结合看了一些开源代码的实现，并没有满足这个建议进行实现，于是做出了自己的思考，现在编译优化，以及智能指针和引用传递的特点，应该不影响智能指针引用计数的变化，及引用传递时，只是一个别名，使用前后，不改变智能指针的使用计数，从而定义函数接口时，使用值传递和引用传递都不受影响，除非使用者在接口调用前后，或者调用的接口内部，自己强行delete智能指针的空间，或者修改其使用计数。
C++基础知识（3）智能指针
01-21
智能指针是C++中的一种特殊指针，它能够自动管理动态分配的内存资源，避免内存泄漏和悬空指针的问题。C++11引入了三种智能指针：shared_ptr、unique_ptr和weak_ptr。 1. shared_ptr：共享的智能指针。多个shared_ptr可以共享同一个对象，并且会自动计数引用次数。当引用计数为0时，对象会被自动销毁。shared_ptr使用引用计数的方式来管理资源，可以通过make_shared函数进行初始化。 ```cpp #include <memory> int main() { std::shared_ptr<int> ptr = std::make_shared<int>(10); std::shared_ptr<int> ptr2 = ptr; // 共享同一个对象 // ... return 0; } ``` 2. unique_ptr：独占的智能指针。每个unique_ptr拥有对对象的唯一所有权，不能被复制或共享。当unique_ptr被销毁时，它所拥有的对象也会被销毁。unique_ptr可以通过new关键字进行初始化。 ```cpp #include <memory> int main() { std::unique_ptr<int> ptr(new int(10)); // ... return 0; } ``` 3. weak_ptr：弱引用的智能指针。它不共享指针，不能操作资源，主要用来监视shared_ptr的生命周期。weak_ptr不会增加引用计数，当shared_ptr销毁后，weak_ptr会自动失效。 ```cpp #include <memory> int main() { std::shared_ptr<int> ptr = std::make_shared<int>(10); std::weak_ptr<int> weakPtr = ptr; // 弱引用 // ... return 0; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值