智能指针学习笔记

已于 2022-08-03 23:00:31 修改
阅读量835 收藏 5
点赞数 8
分类专栏： C++ 文章标签： 学习 c++ 开发语言
于 2022-08-03 22:28:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44387095/article/details/126122486
版权

目录

1 智能指针简介

关于智能指针

概述

2 独占指针：unique_ptr

3 unique_ptr与函数调用

4 计数指针 share_ptr

5 shared_ptr与函数

6 shared_ptr与unique_ptr

7 weak_ptr

1 智能指针简介

关于智能指针

  • 在C++ 11中引入智能指针的概念，使得C++程序员不需要手动释放内存
  • 智能指针的分类：unique_ptr, shared_ptr, weak_ptr 
  • 注意：auto_ptr已经被抛弃

概述

C++指针包含两种

  1. 原始指针
  2. 智能指针：对原始指针的封装，其优点是自动分配内存，不用担心潜在的内存泄露。

智能指针和原始指针的关系

  • 并不是所有的指针可以封装为智能指针，很多时候原始指针更方便

  • 各种指针中，最常用的是原始指针，其次是unique_ptr和shared_ptr

  • weak_ptr是share_ptr的一种补充，应用场景少

接下来思考一个问题，为什么有了智能指针，还需要rust呢？

  • 因为智能指针只解决了一部分问题，即独占/共享所有权指针的释放和传输
  • 智能指针没有从根本上解决C++内存安全的问题，不加以注意依然造成内存安全问题，而rust解决的问题更广泛一些。

2 独占指针：unique_ptr

特点：

  • 在任何给定的时刻，只能有一个指针管理内存
  • 当指针超出作用域时，内存将自动释放
  • 该类型指针不可copy，只可以move

三种创建方式：

  • 通过已有指针创建：需要将指针置为空，并销毁，不然不满足独占作用
  • 通过new创建：同上
  • 通过make_unique创建：推荐使用

unique_ptr可以通过get()获取地址，另外可以通过->调用成员函数，通过*进行解引用。

//cat.h
#ifndef CAT_H
#define CAT_H
#include <string>
#include <iostream>
#include "cat.h"
class Cat
{
public:
    Cat(std::string name);
    Cat() = default;
    ~Cat();
    void cat_info() const
    {
        std::cout << "cat info name: " << name << std::endl;
    }
    std::string get_name() const
    {
        return name;
    }
    void set_cat_name(const std::string& name)
    {
        this->name = name;
    }
private:
    std::string name{ "Mini" };
};
#endif
//cat.cpp
#include "cat.h"

Cat::Cat(std::string name) : name(name)
{
    std::cout << "Constructor of Cat :" << name << std::endl;
}
Cat::~Cat() 
{
    std::cout << "Destructor of Cat :" << name << std::endl;
}
//main.cpp
#include<iostream>
#include<memory>
#include "cat.h"
#include "cat.cpp"
using namespace std;

int main(int argc, char *argv[])
{
    Cat c1("OK");
    c1.cat_info();
    {
        Cat c1("OK");
        c1.cat_info();
    }
    cout << "-------------yz----------" << endl;
    return 0;
}

 

//没有delete由new创建的指针
#include<iostream>
#include<memory>
#inlclude"cat.h"
using namespace std;

int main()
{
    Cat *cp1 = new Cat("");
    cp1->cat_info();
    {
        Cat *cp1 = new Cat("yy");
        cp1->cat_info();
    }
    cout<< "-------------yz----------";
    return 0;
}

以上代码是有问题的，我们没有去释放申请的内存，是不会调用析构函数，内存得不到释放。另外当我们delete两次指针的时候也会出现错误。

因此引入unique_ptr智能指针解决上述问题

代码实现如下

#include<iostream>
#include<memory>
#include "cat.h"
#include "cat.cpp"
using namespace std;

int main(int argc, char *argv[])
{
    //创建unique_ptr方式1
    Cat *cp1 = new Cat("yz");
    std::unique_ptr<Cat> u_cp1(cp1);
    u_cp1->cat_info();
    delete cp1;
    cp1 = nullptr;
    
    cout << "-------------yz----------" << endl;

    //创建unique_ptr方式2
    std::unique_ptr<Cat> u_cp2(new Cat("gg"));
    u_cp2->cat_info();
    cout << "-------------yz----------" << endl;

    //创建unique_ptr方式3
    std::unique_ptr<Cat> u_cp3 = make_unique<Cat>();
    u_cp3->cat_info();
    return 0;

}

但是需要注意的是，方式一好像在最新的g++编译器上不需要delete和置空操作。如下为我的上述代码的输出。

Constructor of Cat :yz
cat info name: yz
Destructor of Cat :yz
-------------yz----------
Constructor of Cat :gg
cat info name: gg
-------------yz----------
cat info name: Mini
Destructor of Cat :Mini
Destructor of Cat :gg
Destructor of Cat :free(): double free detected in tcache 2
Aborted (core dumped)

如果我将delete操作和置空操作删除，例如

#include<iostream>
#include<memory>
#include "cat.h"
#include "cat.cpp"
using namespace std;

int main(int argc, char *argv[])
{
    //创建unique_ptr方式1
    Cat *cp1 = new Cat("yz");
    std::unique_ptr<Cat> u_cp1(cp1);
    u_cp1->cat_info();
    
    cout << "-------------yz----------" << endl;

    //创建unique_ptr方式2
    std::unique_ptr<Cat> u_cp2(new Cat("gg"));
    u_cp2->cat_info();
    cout << "-------------yz----------" << endl;

    //创建unique_ptr方式3
    std::unique_ptr<Cat> u_cp3 = make_unique<Cat>();
    u_cp3->cat_info();
    return 0;

}

输出为

Constructor of Cat :yz
cat info name: yz
-------------yz----------
Constructor of Cat :gg
cat info name: gg
-------------yz----------
cat info name: Mini
Destructor of Cat :Mini
Destructor of Cat :gg
Destructor of Cat :yz

下面介绍解引用和取地址操作，以方式为例

#include<iostream>
#include<memory>
#include "cat.h"
#include "cat.cpp"
using namespace std;

int main(int argc, char *argv[])
{
    //创建unique_ptr方式3
    std::unique_ptr<int> u_cp3 = make_unique<int>(200);
    cout<<"* u_cp3 = "<<* u_cp3<<endl;
    cout<<"get adress"<<u_cp3.get()<<endl;
    return 0;

}

输出为

* u_cp3 = 200
get adress0x55e978458e70

3 unique_ptr与函数调用

  • unique_ptr是不可Copy，只可以Move
  • 在做函数参数或返回值中一定要注意所有权

注意事项：

Passing by value

  • 需要注意std::move来转移内存拥有权
  • 如果参数之间传入std:make_unique语句 自动转换为move
#include<iostream>
#include<memory>
#include "cat.h"
#include "cat.cpp"
using namespace std;

void Passing_by_value( std::unique_ptr<Cat> c){
    c->cat_info();
}

int main(int argc, char *argv[])
{
    //创建unique_ptr方式3
    std::unique_ptr<Cat> u_cp1 = make_unique<Cat>("haha");
    Passing_by_value(std::move(u_cp1));//需要注意std::move来转移内存拥有权,否则报错。另外move后也不能再使用u_cp1
    Passing_by_value(std::make_unique<Cat>("xixi"));
    
    return 0;

}

从下面输出结果看到，在move操作转移所有权后会调用Passing_by_value函数和析构函数，说明智能指针不再可用。

Constructor of Cat :haha
cat info name: haha
Destructor of Cat :haha
Constructor of Cat :xixi
cat info name: xixi
Destructor of Cat :xixi

Passing by reference

  • 如果设置参数为const则不能改变指向，比如说reset()
  • reset()方法为智能指针清空方法。当传常引用时，不可以用reset()清空智能指针。
#include<iostream>
#include<memory>
#include "cat.h"
#include "cat.cpp"
using namespace std;

void Passing_by_ref( const std::unique_ptr<Cat> &c){
    c->set_cat_name("ee");
    c->cat_info();
}

int main(int argc, char *argv[])
{
    //创建unique_ptr方式3
    std::unique_ptr<Cat> u_cp1 = make_unique<Cat>("haha");
    Passing_by_ref(u_cp1);//需要注意std::move来转移内存拥有权,否则报错。另外move后也不能再使用u_cp1
    u_cp1->cat_info();
    
    return 0;

}

由下列输出结果可得，传引用可以修改变量值。

Constructor of Cat :haha
cat info name: ee
cat info name: ee
Destructor of Cat :ee

Return by value

  • 指向一个local object
  • 可以作为链式函数
#include<iostream>
#include<memory>
#include "cat.h"
#include "cat.cpp"
using namespace std;

std::unique_ptr<Cat> get_unique_ptr()//return by value
{
    std::unique_ptr<Cat> p_dog = std::make_unique<Cat>("dog");
    cout<<"unique_ptr adresss"<<p_dog.get()<<endl;
    cout<<"unique_ptr adresss"<<&p_dog<<endl;
    return p_dog;
}

int main(int argc, char *argv[])
{
   
    get_unique_ptr()->cat_info();//链式调用
    
    return 0;

}

输出为

Constructor of Cat :dog
unique_ptr adresss0x55a6558e1e70
unique_ptr adresss0x7ffeb6c9ae70
cat info name: dog
Destructor of Cat :dog

4 计数指针 share_ptr

  • 计数指针 share_ptr又称为共享指针
  • 与unique_ptr不同的是可以共享数据
  • share_ptr创建了一个计数器与类对象所指的内存相关联
  • Copy则计数加1，销毁则减1
  • api为use_count()，查询引用计数
#include<iostream>
#include<memory>
#include "cat.h"
#include "cat.cpp"
using namespace std;


int main(int argc, char *argv[])
{
   
    std::shared_ptr<Cat> p1 = make_shared<Cat>("aa");
    p1->cat_info();
    cout<<"p1 count: "<<p1.use_count()<<endl;
    std::shared_ptr<Cat> p2 = p1;
    cout<<"p1 count: "<<p1.use_count()<<endl;
    cout<<"p2 count: "<<p2.use_count()<<endl;
    p1=nullptr;
    cout<<"p1 count: "<<p1.use_count()<<endl;
    cout<<"p2 count: "<<p2.use_count()<<endl;
    return 0;

}

 输出为

Constructor of Cat :aa
cat info name: aa
p1 count: 1
p1 count: 2
p2 count: 2
p1 count: 0
p2 count: 1
Destructor of Cat :aa

值得注意的是，无论引用计数为多少，数据只有一套。无论引用计数为多少，程序运行结束时只会调用一次析构函数。

5 shared_ptr与函数

  • shared_ptr passed by value ：copy时引用计数加1
#include<iostream>
#include<memory>
#include "cat.h"
#include "cat.cpp"
using namespace std;

void pass_by_value(std::shared_ptr<Cat> c){
    c->cat_info();
    cout<<"count: "<<c.use_count()<<endl;
}

int main(int argc, char *argv[])
{
   
    std::shared_ptr<Cat> p1 = make_shared<Cat>("aa");
    p1->cat_info();
    pass_by_value(p1);
    cout<<"p1 count: "<<p1.use_count()<<endl;
    
    return 0;

}

由下面可得，当进入函数体时引用计数加1，离开函数体减1。

Constructor of Cat :aa
cat info name: aa
cat info name: aa
count: 2
p1 count: 1
Destructor of Cat :aa

  • shared_ptr passed by ref:const表示不可以改变指向

类似与unique_ptr

  • return by value：链式调用

l类似与unique_ptr

6 shared_ptr与unique_ptr

  • 不能将shared_ptr转换为unique_ptr
  • unique_ptr可以转换为shared_ptr:通过std::move转换
  • 将你的函数返回unique_ptr是一种常见的设计模式，这样可以提高代码的复用性，你可以随时改变为shared_ptr
#include<iostream>
#include<memory>
#include "cat.h"
#include "cat.cpp"
using namespace std;

std::unique_ptr<Cat> pass_by_value(){
    std::unique_ptr<Cat> c = make_unique<Cat>("cc");
    return c;
}

int main(int argc, char *argv[])
{
    std::unique_ptr<Cat> p0 = make_unique<Cat>("bb");
    std::shared_ptr<Cat> p1 = std::move(p0);//unique_ptr转换为shared_ptr
    p1->cat_info();
    cout<<"p1 count: "<<p1.use_count()<<endl;
    
    
    std::shared_ptr<Cat> p3 = pass_by_value();//直接用shared_ptr接收unique_ptr
    cout<<"p3 count"<<p3.use_count()<<endl;
    return 0;

}

输出为

Constructor of Cat :bb
cat info name: bb
p1 count: 1
Constructor of Cat :cc
p3 count1
Destructor of Cat :cc
Destructor of Cat :bb

7 weak_ptr

  • weak_ptr并不拥有所有权
  • 不能调用->和解引用*

weak_ptr为什么存在呢？

A类中有一个需求需要存储其他A类对象的信息，如果使用shared_ptr，那么在销毁时会遇到循环依赖问题，所以我们这里需要用一个不需要拥有权的指针来标记同类对象。

weak_ptr可以通过lock()函数来提升为shared_ptr（类型转换）

例1

#include<iostream>
#include<memory>
#include "cat.h"
#include "cat.cpp"
using namespace std;


int main(int argc, char *argv[])
{
    std::shared_ptr<Cat> p0 = make_shared<Cat>("bb");
    std::weak_ptr<Cat> p1 = p0;
    cout<<"p0 use_count: "<<p0.use_count()<<endl;

    std::shared_ptr<Cat> p2 = p1.lock();
    cout<<"p0 use_count: "<<p0.use_count()<<endl;

    return 0;

}

输出如下，可以看出weak_ptr不会增加引用计数，将weak_ptr使用lock()函数转换后可以增加引用计数

Constructor of Cat :bb
p0 use_count: 1
p0 use_count: 2
Destructor of Cat :bb

解决循环依赖问题

更改cat.h代码如下

#ifndef CAT_H
#define CAT_H
#include <string>
#include <iostream>
#include "cat.h"
#include<memory>
class Cat
{
public:
    Cat(std::string name);
    Cat() = default;
    ~Cat();
    void cat_info() const
    {
        std::cout << "cat info name: " << name << std::endl;
    }
    std::string get_name() const
    {
        return name;
    }
    void set_cat_name(const std::string& name)
    {
        this->name = name;
    }
    void set_friend(std::shared_ptr<Cat> c){
        m_friend = c;
    }
private:
    std::string name{ "Mini" };
    std::shared_ptr<Cat> m_friend;
};
#endif

 此时就需要用weak_ptr来解决上图中的问题了，我们需要修改cat.h代码，如下图

 此时再去运行main函数，就发现问题已经解决了

 

@Finish_all
关注
  • 8
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
对智能指针的学习
这是一个博客
03-29 129
个人对智能指针的理解 智能指针类，方便内存的管理。对于一般指针，空间被new出来后，需要显式地调用delete从而释放空间，否则就会有内存泄漏的问题。而智能指针的智能正是体现在这一方面，它不需要显式地调用delete，从而提高代码的容错率，减少了内存泄漏的可能。 智能指针实质上是一个对象，但是表现却像一个指针，正常情况下，可以使用指针的->和*操作运算符。 个人认为，智能指针的实质是用处于栈...
指针学习笔记
暗影之龙的博客
01-25 175
内存地址所指向的是当前存储数据的首地址，数据类型所指向的是当前存储数据的长度（占用多大的内存空间）。 指针是一种数据类型，也需要占用内存空间，它的属性是指向一个数据类型的首地址和长度。指针存储的是地址，长度取决于指针的类型。 在32位系统下，指针占用的空间为32bit（4byte）；在64位系统下，指针占用的空间为64bit（8byte）。 指针的用处： 1.函数传递参数时，使用指针能节省
C++中的智能指针
cz的博客
03-16 542
1 智能指针的基本用法 智能指针设计的初衷就是可以帮助我们管理堆上申请的内存，可以理解为开发者只需要申请，而释放交给智能指针。 目前 C++11 主要支持的智能指针为以下几种，都定义在 memory 头文件中 unique_ptr shared_ptr weak_ptr 1.1 unique_ptr 先上代码 class A { public: void do_something() {} }; void test_unique_ptr(bool open) { std::unique
C++ 智能指针
weixin_54670782的博客
12-01 3704
智能指针 输入问题： 给定一个字符串，不知道有几个字符，怎样输入？ 使用cin.getline(); 输入一行。 智能指针概念 智能指针主要是针对裸指针进行了一次面向对象的封装，在构造函数中初始化资源地址，在析构函数中释放资源。当资源应该被释放时，指向它的智能指针可以确保自动释放它。 RAII RAII 对堆上空间进行自动化管理——利用对象自动析构的机制。 malloc， new 等动态分配的对象，很有可能忘记了去释放资源而导致泄露。 对于一个对象而言，在构造函数的时候申请空间，而在析构函数（在离开
c++的智能指针（5） -- weak_ptr
最新发布
weixin_68026222的博客
04-22 1052
就是我们的A，B类中都存在有指向对方的智能指针，当我们在main中定义指向类A和类B动态空间的智能指针的时候，同时，我们使用setPtr函数，将其内部的智能指针进行了赋值，分别指向了对方。也就是，我们不让类B中的智能指针指向类A的动态空间，这样类A的动态空间的引用计数就为1，在指向类A空间的智能指针pa释放的时候，引用计数减为0，这样类A的动态空间就会被释放。这时候，对于动态开辟的A类和B类的动态空间而言，都同时存在着两个智能指针管理(一个是main中定义的，一个是类中的成员)，引用计数为2。
C++智能指针shared_ptr的使用方法
qq_39618959的博客
11-09 1159
shared_ptr内部使用了引用计数的方式对同一块内存进行引用，对于同一块内存，每多一个对它的指向，所有指针的内部的引用计数就会加一，每减少一个对它的指向，所有指针内部的引用计数就会减一，当引用计数减到0后，这块内存就被释放。
Qt智能指针--QPointer
hw5230的博客
03-11 1711
QPointer是Qt提供的一个比较特别的智能指针，和其它智能指针有很大的不同，该智能指针专门为自动释放内存资源而设计的。
c++学习笔记
04-07
对于更高级的主题，笔记可能涵盖了一些C++11及其后续标准引入的新特性，比如智能指针（shared_ptr、unique_ptr等）、右值引用、lambda表达式、auto关键字和范围for循环等，这些都显著提升了C++的现代性和可读性。...
ROS和C马克学习笔记
08-27
对于ROS开发者来说，理解和运用智能指针（如std::shared_ptr）来管理内存是非常重要的，因为ROS中的节点可能会并发执行，正确管理资源可以避免内存泄漏。此外，学习如何利用C++11及更高版本的新特性，如lambda表达式...
雨痕的学习笔记 2014最新版
01-07
《雨痕的学习笔记 2014最新版》是一份宝贵的学习资源，涵盖了C、Go、Python这三种重要编程语言的最新知识。这份笔记由知名技术爱好者“雨痕”在2014年10月进行了第三次修订，旨在帮助学习者深入理解并掌握这些语言的...
C++ 学习笔记 整理
10-31
6. **C++11及以后的新特性**：C++11引入了许多新特性，如auto关键字、右值引用、lambda表达式、智能指针等，C++14和C++17进一步增强了这些特性，使得C++更加现代化和高效。 7. **内存管理**：理解指针是学习C++的...
C++智能指针shared_ptr
天启的博客
07-05 1578
每种智能指针都是以类模版的方式实现的，shared_ptr<T>（其中T表示指针指向的具体数据类型）的第一位于<memory>头文件。 shared_pre是C++11提供的一种智能指针类，它可以在任何地方不使用时自动删除相关指针，从而帮助彻底解决内存泄露和悬空指针的问题。不同的shared_pre对象可以与相同的指针相关联，且在内部使用引用计数机制。 每个shared_ptr对象最内部指向两个内存位置：指向对象的指针；用于控制引用计数数据的指针。 ...
c++里面的四种智能指针以及代码实现
ypshowm的博客
04-04 2069
C++里面的四个智能指针: auto_ptr, shared_ptr, weak_ptr, unique_ptr 其中后三个是c++11支持，并且第一个已经被11弃用。 为什么要使用智能指针： 智能指针的作用是管理一个指针，因为存在以下这种情况：申请的空间在函数结束时忘记释放，造成内存泄漏。使用智能指针可以很大程度上的避免这个问题，因为智能指针就是一个类，当超出了类的作用域是，类会自动调用析构...
C++_指针
weixin_46365033的博客
08-13 203
文章目录指针的概念指针的有效性指针的运算一维数组与指针指针与字符串 指针的概念 函数中，只能返回一个值，虽然数组能返回多个值，但是是同一个类型的。那么如何返回多个不同的值呢？ 指针的出现很好地解决了这一问题。 p指向i，指的是p存放i的地址。 不同的类型会让系统认为，指向的对象包含x个字节。 指针的类型应该和指向的对象的类型一致。 指针的有效性 随机给了一个地址，里面可能是一个很重要的地址，因此不可以随机改变其中的值。 迷途指针产生的原因： 指针的运算 通过比较指针
c语言如何给指针清零归位,C语言中对于二进制数据位清0和置1操作（普通变量+数组+指针）...
weixin_28871645的博客
05-19 3669
一、基本知识(一)位bit运算符位与&运算符特点位或|运算符特点(二)移位运算符(三)位运算符和移位运算符结合(bit位清0与置1公式)二、例程(一)清0与置1推导步骤(二)借助数组将某一位清0和置1(三)使用指针清0和 置1一、基本知识(一)位(bit)运算符1、功能：这些运算符就是专门操作内存中的二进制数位与:&(目的：将二进制数的bit清0)位或:|(目的：将二进制数的bit...
c++ 智能指针auto_ptr (c++98)、shared_ptr(c++ 11)、unique_ptr(c++ 11)、weak_ptr(c++ 11)
baidu_16370559的博客
07-01 1457
auto_ptr就是动态分配对象以及当对象不再需要时自动执行清理。 使用std::auto_ptr，要#include <memory>。 构造和析构 1.将已存在的指向动态内存的普通指针作为参数来构造 int*p=newint(0); auto_ptr<int>ap(p); 2.直接构造智能指针 auto_ptr< int > api( new int( 0) ); 因为auto_ptr析构的时候肯定会删除他所拥有的那个对象，两个auto......
C++智能指针
weixin_45483780的博客
03-23 807
C++智能指针区别 介绍：C++里面有四个智能指针: auto_ptr, shared_ptr, weak_ptr, unique_ptr 其中后三个是c++11支持，并且第一个已经被11弃用。 智能指针的作用？ 智能指针的作用是用来管理一个指针。 为么要使用智能指针？ 当申请的空间在函数结束时忘记释放，将会造成内存泄漏。而智能指针是一个类，当超出了类的作用域时，类会自动调用析构函数，析构函数会自动释放资源。所以智能指针在函数结束时会自动释放内存空间，不需要手动释放内存空间，这样就避免了内存泄漏。 一. a
C++学习笔记：面向对象与泛型编程探索
Boost库是C++社区广泛使用的开源库，包含了大量高质量的工具和库，如智能指针、线程库、算法库等，它帮助开发者更好地利用C++的特性并简化复杂任务。 C++对象模型是理解C++底层工作原理的关键，它涉及到对象的内存...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@Finish_all

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值