C++的智能指针

夕泠爱吃糖2024-11-11 8:52

智能指针

智能指针是用于管理动态分配内存的一种工具，它们可以帮助开发者自动管理内存，避免内存泄漏和悬空指针等问题。智能指针通过RAII（资源获取即初始化）理念确保资源的自动释放。

std::shared_ptr

初始化

共享智能指针是指多个智能指针可以同时管理同一块有效的内存，shared_ptr 可以被复制，每次复制时引用计数增加，当最后一个指针被销毁时，资源才会被释放。共享智能指针share_ptr是一个模板类，如果进行初始化有三种方式如下：

1.通过构造函数初始化

2.std::make_shared辅助函数

3.reset方法

共享智能指针对象初始化完毕之后就指向了要管理的那块堆区内存，如果想要查看当前有多少个智能指针同时管理着这块内存可以使用共享智能指针提供的一个成员函数use_count。

构造函数初始化
cpp 复制代码 
#include<iostream>
#include<memory>
using namespace std;
/*
share_ptr:共享智能指针，一块堆区内存可以被多个share_ptr所指向
*/
int main()
{
    //初始化 share_ptr
    //构造函数初始化
    shared_ptr<int>ptr1(new int(520));
    cout<<"ptr1的引用计数："<<ptr1.use_count()<<endl;
    shared_ptr<char>ptr2(new char[520]);//指向一块字符数组对应的堆区内存
    cout<<"ptr2的引用计数："<<ptr2.use_count()<<endl;
    shared_ptr<int>ptr3;//默认构造
    cout<<"ptr3的引用计数："<<ptr3.use_count()<<endl;
    shared_ptr<int>ptr4(nullptr);
    cout<<"ptr4的引用计数："<<ptr4.use_count()<<endl;
}

结果：
    ptr1的引用计数：1
    ptr2的引用计数：1
    ptr3的引用计数：0
    ptr4的引用计数：0
// 如果智能指针被初始化了一块有效内存，那么引用计数+1，如果智能指针没有被初始化
// 或者初始化为空，引用计数为0；
std::make_shared()

std::make_shared()就可以完成内存对象的创建并将其初始化给智能指针。

cpp 复制代码 
#include<iostream>
#include<string>
#include<memory>
using namespace std;
class Test
{
  public:
  Test()
  {
      cout<<"无参构造函数"<<endl;  
  }  
  Test(int x)
  {
      cout<<"int类型构造函数"<<x<<endl;  
  }
  Test(string str)
  {
      cout<<"string类型的构造函数"<<str<<endl;  
  }
  ~Test()
  {
      cout<<"析构函数"<<endl;  
  }
};
int main()
{
    //使用智能指针管理一块int型的堆区内存，内部引用计数为1
    shared_ptr<int>ptr1=make_shared<int>(520);
    cout<<"ptr1管理的内存引用计数："<<ptr1.use_count()<<endl;
    
    shared_ptr<Test>ptr2=make_shared<Test>();
    cout<<"ptr2管理的内存引用计数："<<ptr2.use_count()<<endl;
    
    shared_ptr<Test>ptr3=make_shared<Test>();
    cout<<"ptr3管理的内存引用计数："<<ptr3.use_count()<<endl;
    
    shared_ptr<Test>ptr4=make_shared<Test>("AAAA");
    cout<<"ptr4管理的内存引用计数："<<ptr4.use_count()<<endl;
    
    shared_ptr<Test>ptr5(new Test(200));
    cout<<"ptr5管理的内存引用计数："<<ptr5.use_count()<<endl;
    
    打印如下
    ptr1管理的内存引用计数：1
    无参构造函数
    ptr2管理的内存引用计数：1
    int类型构造函数 520
    ptr3管理的内存引用计数：1
    string类型的构造函数AAAA
    ptr4管理的内存引用计数：1
    int类型的构造函数
    ptr5管理的内存引用计数：1
    
    析构函数
    析构函数
    析构函数
    析构函数
}
reset方法
cpp 复制代码 
#include<iostream>
#include<string>
#include<memory>
using namespace std;
int main()
{
    //使用智能指针管理一块int型的堆区内存，内部引用计数为1
    shared_ptr<int>ptr1=make_shared<int>(520);
    shared_ptr<int>ptr2=ptr1
    shared_ptr<int>ptr3=ptr1
    shared_ptr<int>ptr4=ptr1
    
     
    cout<<"ptr1管理的内存引用计数："<<ptr1.use_count()<<endl;
    cout<<"ptr2管理的内存引用计数："<<ptr2.use_count()<<endl;
    cout<<"ptr3管理的内存引用计数："<<ptr3.use_count()<<endl;
    cout<<"ptr4管理的内存引用计数："<<ptr4.use_count()<<endl;
    
    ptr4.reset();
    cout<<"ptr1管理的内存引用计数："<<ptr1.use_count()<<endl;
    cout<<"ptr2管理的内存引用计数："<<ptr2.use_count()<<endl;
    cout<<"ptr3管理的内存引用计数："<<ptr3.use_count()<<endl;
    cout<<"ptr4管理的内存引用计数："<<ptr4.use_count()<<endl;
    shared_ptr<int>ptr5;
    ptr5.reset(new int(250));
     cout<<"ptr5管理的内存引用计数："<<ptr5.use_count()<<endl;
     return 0;
}

打印结果：
     ptr1管理的内存引用计数：4
     ptr2管理的内存引用计数：4
     ptr3管理的内存引用计数：4
     ptr4管理的内存引用计数：4
     
     ptr1管理的内存引用计数：3
     ptr2管理的内存引用计数：3
     ptr3管理的内存引用计数：3
     ptr4管理的内存引用计数：0
     
     ptr5管理的内存引用计数：1

注意 ：不要使用同一个原始指针初始化不同的智能指针，会造成同一块内存重复释放。

例：

cpp 复制代码 
 int*p =new int(12);
 shared_ptr<int>p1(p),p2(p);
 cout<<p1.use_count()<<endl;   
 cout<<p2.use_count()<<endl;   
 //会报错

拷贝构造和移动构造函数初始化

当一个智能指针被初始化之后，就可以通过这个智能指针初始化其他新对象。在创建新对象的时候，对应的拷贝构造函数或者移动构造函数就被调用了。

cpp 复制代码 
//构造函数
shared_ptr<int>ptr1(new int(520));
cout<<"ptr1管理的内存引用计数："<<ptr1.use_count()<<endl;
//拷贝构造函数
shared_ptr<int>ptr2(ptr1);
cout<<"ptr2管理的内存引用计数："<<ptr2.use_count()<<endl;
shared_ptr<int>ptr3=ptr1;
cout<<"ptr3管理的内存引用计数："<<ptr3.use_count()<<endl;
//移动构造函数
shared_ptr<int>ptr4(std::move(ptr1));
cout<<"ptr4管理的内存引用计数："<<ptr4.use_count()<<endl;
std::shared_ptr<int> ptr5=std::move(ptr2);
acout<<"ptr5管理的内存引用计数："<<ptr5.use_count()<<endl;
打印结果如下：
        ptr1管理的内存引用计数：1
        ptr2管理的内存引用计数：2
        ptr3管理的内存引用计数：3
        ptr4管理的内存引用计数：3
        ptr5管理的内存引用计数：3

如果使用拷贝的方式初始化共享智能指针，这两个对象会同时管理同一块内存，堆内存对应的引用技术也会增加。如果使用移动构造函数的方式初始化智能指针对象，只是转让了内存的所有权，管理内存的对象不会增加，因此内存引用技术不会增加。

获取原始指针

get()函数

cpp 复制代码 
int main()
{shared_ptr<int> p(new int)
*p=100;
cout<<*p.get()<<" "<<*p<<endl;
return 0;
}

结果：
    100 100

std::unique_ptr

初始化

1.独占所有权：std::unique_ptr是一个独占型的智能指针，它不允许其他的智能指针共享其内部的指针。

2.不可复制：可以通过它的构造函数初始化一个独占智能指针，但是不允许通过赋值将一个unique_ptr赋值给另一个unique_ptr。

3.自动释放：当 unique_ptr 超出作用域时，自动释放内存。

cpp 复制代码 
#include<iostream>
#include<string>
#include<memory>
using namespace std;
int main()
{
	//通过构造函数初始化对象
	unique_ptr<int> ptr1(new int(10));
    std::cout << *ptr1 << std::endl; // 输出 10  

    unique_ptr<int> p2 = std::move(p1); // 移动所有权 
	
    //下面写法错误不可复制
	unique_ptr<int>ptr2 = ptr1;//报错
	return 0;
}

unique_ptr不允许被复制，但是可以通过函数返回给其他的unique_ptr，还可以通过std::move()转移给其他的unique_ptr。还是一个unique_ptr独占一个地址。

cpp 复制代码 
#include<iostream>
#include<string>
#include<memory>
using namespace std;

unique_ptr<int> fun()
{
	//独占智能指针unique_ptr 它不允许其他的智能指针共享内部的指针
	unique_ptr<int> a(new int(10));
	return a;
}


int main()
{
	unique_ptr<int> b = fun();//移动构造
	cout << *b << endl;//10
	return 0;
}

使用reset方法可以让unique_ptr解除对原始内存的管理。也可以用来初始化一个独占的智能指针。

cpp 复制代码 
#include<iostream>
#include<string>
#include<memory>
using namespace std;


int main()
{
	unique_ptr<int> ptr1(new int(10));
	unique_ptr<int>ptr2;
	ptr1.reset();//解除对原始内存的管理
	ptr2.reset(new int(250));//重新指定智能指针管理的原始内存

	
	return 0;
}

如果想要获取独占智能指针管理的原始地址，可以调用get()方法。

cpp 复制代码 
#include<iostream>
#include<string>
#include<memory>
using namespace std;


int main()
{
	unique_ptr<int> ptr1(new int(10));
	unique_ptr<int>ptr2=move(ptr1);
	ptr2.reset(new int(250));
	cout << *ptr2.get() << endl;//得到内存地址中储存的实际数值

	return 0;
}


结果：
      250

std::weak_ptr

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

防止循环引用：通常与 shared_ptr 一起使用，可以避免因循环引用导致的内存泄漏。

初始化

cpp 复制代码 
#include<iostream>
#include<string>
#include<memory>
using namespace std;


int main()
{
	shared_ptr<int> sp(new int);

	//week_ptr<int>wp1; 构造了一个空weak_ptr对象weak_ptr<int>wp1;
	weak_ptr<int>wp1;

	//week_ptr<int>wp2(wp1);通过构造了一个空weak_ptr对象构造了另一个空weak_ptr对象
	weak_ptr<int>wp2(wp1);

	//week_ptr<int>wp3(sp);通过一个shared_ptr对象构造了一个可用的weak_ptr实例对象
	 weak_ptr<int>wp3(sp);

    //wp4=sp;通过一个shared_ptr对象构造了一个可用的weak_ptr实例对象(这是一个隐式类型转换)
	  weak_ptr<int>wp4;
	   wp4 = sp;

	//wp5 = wp3; 通过一个weak_ptr对象构造了一个可用的weak_ptr实例对象
	   weak_ptr<int>wp5;
	   wp5 = wp3;

		 return 0;
}

循环引用

例：

cpp 复制代码 
#include <iostream>  
#include <memory>  

class B;  // 前向声明  

class A {  
public:  
    std::shared_ptr<B> b_ptr;  
    ~A() { std::cout << "A destructed\n"; }  
};  

class B {  
public:  
    std::shared_ptr<A> a_ptr;  
    ~B() { std::cout << "B destructed\n"; }  
};  

void example() {  
    std::shared_ptr<A> a(new A());  
    std::shared_ptr<B> b(new B());  

    a->b_ptr = b;  // A 持有 B 的共享指针  
    b->a_ptr = a;  // B 持有 A 的共享指针  
}  

int main() {  
    example();  
    // 此时不会调用 A 和 B 的析构函数，因为它们相互持有，引用计数不为零  
    return 0;  
}

当 example 函数返回时，a 和 b 的引用计数都不会降为零，因此它们的析构函数不会被调用，导致内存泄漏。

解决循环引用

为了解决循环引用的问题，通常可以使用 std::weak_ptr。std::weak_ptr 是一种对 std::shared_ptr 的非拥有权引用，不会增加引用计数，因此可以用来打破循环引用。

cpp 复制代码 
#include <iostream>  
#include <memory>  

class B;  // 前向声明  

class A {  
public:  
    std::weak_ptr<B> b_ptr;  // 使用 weak_ptr  
    ~A() { std::cout << "A destructed\n"; }  
};  

class B {  
public:  
    std::shared_ptr<A> a_ptr;  
    ~B() { std::cout << "B destructed\n"; }  
};  

void example() {  
    std::shared_ptr<A> a(new A());  
    std::shared_ptr<B> b(new B());  

    a->b_ptr = b;  // A 持有 B 的弱引用  
    b->a_ptr = a;  // B 持有 A 的共享指针  
}  

int main() {  
    example();  
    // 此时 A 和 B 的析构函数都会被调用，因为弱引用不影响引用计数  
    return 0;  
}

use_count()

通过调用tsd::weak_ptr类提供的use_count()方法可以获得当前所观察资源的引用计数。

cpp 复制代码 
#include<iostream>
#include<string>
#include<memory>
using namespace std;


int main()
{
	shared_ptr<int> sp(new int);
	weak_ptr<int>wp1;
	weak_ptr<int>wp2(wp1);
	 weak_ptr<int>wp3(sp);
	  weak_ptr<int>wp4;
		 wp4 = sp;
		 weak_ptr<int>wp5;
		 wp5 = wp3;
		 cout << "use_count：" <<  endl;
		 cout << "wp1：" << wp1.use_count() << endl;
		 cout << "wp2：" << wp2.use_count() << endl;
		 cout << "wp3：" << wp3.use_count() << endl;
		 cout << "wp4：" << wp4.use_count() << endl;
		 cout << "wp5：" << wp5.use_count() << endl;
		 return 0;
}

结果：
    use_count：
    wp1：0
    wp2：0
    wp3：1
    wp4：1
    wp5：1

通过打印的结果知道，虽然弱引用智能指针 wp3,wp4,wp5检测的资源是同一个但是引用计数并没有发生任何变化，也进一步证明了weak_ptr只是检测资源，并不管理资源。

expired（）

通过调用std::weah_ptr类提供的expired（）方法来观测的资源是否已经释放。

cpp 复制代码 
#include<iostream>
#include<string>
#include<memory>
using namespace std;

int main()
{
	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;
		
		 return 0;
}

结果：
    1  weak is not xpired
    2 weak is expired

weak_ptr检测的就是shared_ptr管理的资源，当共享智能指针调用shared.reset()之后管理的资源被释放，因此weak.expired()函数的结果返回true，表示监视的资源已经不存在了。

lock

通过调用std::weak_ptr类提供的lock()方法来获取管理检测的shared_ptr对象。

cpp 复制代码 
#include<iostream>
#include<string>
#include<memory>
using namespace std;


int main()
{
    shared_ptr<int> sp1, sp2;
    weak_ptr<int>wp;

    sp1 = std::make_shared<int>(520);
    wp = sp1;
    sp2 = wp.lock();
    cout << "use_count:" << wp.use_count() << endl;

    sp1.reset();
    cout << "use_count:" << wp.use_count() << endl;

    sp1 = wp.lock();
    cout << "use_count:" << wp.use_count() << endl;
    
    
    cout << "*sp1:" << wp.use_count() << endl;
    cout << "*sp2:" << wp.use_count() << endl;
    return 0;
}

结果：
    use_count:2
    use_count:1
    use_count:2
    *sp1:2
    *sp2:2

sp2=wp.lock();通过调用lock()方法得到用于管理wseak_ptr对象所检测的资源的共享智能指针对象，使用这个对象初始化sp2,此时所检测资源的引用计数为2。

sp1.reset()。共享智能指针sp1被重置weak_ptr对象所检测的资源的引用计数减1。

sp1=wp.lock().sp1重新被初始化，并且管理的还是weak_ptr对象所检测的资源，因此引用计数加1。

共享智能指针对象sp1和sp2管理的是同一块内存，因此最终打印的内存中的结果是相同的，都是520。

reset

通过调用std::weak_ptr类提供的reset()方法来清空对象，使其不检测任何资源。

cpp 复制代码 
#include<iostream>
#include<string>
#include<memory>
using namespace std;

int main()
{
	shared_ptr<int> sp(new int(10));
	weak_ptr<int>wp(sp);
	cout << "1  wp" << (wp.expired() ? "is" : "is not") << "expired" << endl;

	wp.reset();
	cout << "2 wp" << (wp.expired() ? "is" : "is not") << "expired" << endl;
		
		 return 0;
}

结果：
    wp is not expired
    wp is expired
相关推荐
究极无敌暴龙战神3 分钟前
java 面向对象高级
java·开发语言
AnFany5 分钟前
LeetCode【0016】最接近的三数之和
python·算法·leetcode·双指针·分治法
_OLi_13 分钟前
力扣 LeetCode 27. 移除元素（Day1：数组）
算法·leetcode·职场和发展
李歘歘26 分钟前
深度学习——前向传播与反向传播、神经网络（前馈神经网络与反馈神经网络）、常见算法概要汇总
深度学习·神经网络·算法
想七想八不如1140828 分钟前
【数据分析与数据挖掘】决策树算法
算法·数据挖掘·数据分析
Enoch88830 分钟前
Day09 C++ 存储类
java·jvm·c++
一只专注api接口开发的技术猿31 分钟前
python 京东api怎么写
大数据·开发语言·数据库·python
不太爱喝水41 分钟前
外星人入侵
开发语言·python·pygame
长弓聊编程1 小时前
如何使用gtest编写C++单元测试代码
c++·单元测试
TomSmile_WorkSpace1 小时前
RabbitMq项目实战--延迟队列实现超时订单处理
开发语言·后端·ruby
热门推荐
01聊聊 Python 中的同步原语，为什么有了 GIL 还需要同步原语02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03Windows10安装PCL1.14.0及点云配准04软件工程从理论到实践客观题汇总(头歌第一章至第八章)05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09Coze扣子平台完整体验和实践（附国内和国际版对比）10VSCode插件 —— Cody AI （免费AI助手！）