智能指针详解

已于 2023-10-11 17:55:41 修改
阅读量48 收藏
点赞数
分类专栏： Cpp与STL 文章标签： c++
于 2023-10-09 21:26:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Feeliamn/article/details/133712827
版权

智能指针

概述：三种智能指针 shared_ptr \ unique_ptr \ weak_ptr

文章目录

使用智能指针，首先需要包含memory头文件且智能指针都是在std命名空间中

#include <memory>
using namespace std;

shared_ptr

共享指针，用于多个指针指向同一个资源

基本用法

定义并初始化

shared_ptr<int>p;
p = make_shared<int>(100);

make_shared会动态分配一块内存，作用与new一样，但make_shared效率更高

shared_ptr<int>p {new int(100)};
shared_ptr<int>p {make_shared<int>(100)};

使用

class ball
{
    public:
	Ball(){
        cout <<"A ball appears."<<endl;
    }
    ~Ball(){
        cout <<"A ball disappears."<<endl
    }
    void Bounce(){
        cout <<"A ball jumps."<<endl;
    }

};

int main()
{
	shared_ptr<Ball>p make_shared<Ball>();
	cout <<p.use_count()<<endl;  //输出1
	shared_ptr<Ball>p2 = p;
	cout <<p.use_count()<< " " <<p2.use_count()<endl;//输出2 2
	shared_ptr<Ball>p3 = p;
	cout <<p.use_count()<<" "<<p2.use_count()<<" "
	        <<p3.use_count()<endl;//输出3 3 3
	p.reset();
	p2.reset();
	p3.reset();//输出A ball disappears.
}

shared_ptr采用 ”引用计数“ 的方式管理，

每增加一个shared_ptr指向同一个对象时，记录引用计数+1，

当某个共享指针 reset 或者销毁的时候，引用计数-1，

引用计数为0，程序会自动释放对象

BTW

当某个函数接受的参数只能是裸指针，可以使用shared_ptr的get()方法来获取裸指针指向当前资源

当所有shared_ptr被销毁，但裸指针仍存在时，该指针所指向的内存仍然释放！再操作裸指针可能造成严重后果

Ball* rp = p.get();

避免裸指针与共享指针共用。

shared_ptr进阶用法
void close file(FILE*fp){
    if (fp =nullptr)return;
    fclose(fp);
    cout <<"File closed."<<endl;
}
int main(
    FILE*fp fopen("data.txt","w");
    //引用计数为0 执行close_file()关闭文件而不是delete指针
    shared_ptr<FILE>sfp {fp, close_file};
    if (sfp == nullptr)
    	cerr <<"Error opening file."<<endl;
    else cout <<"File opened." <<endl;
}

reset接受参数

shared_ptr<Ball>sp;
sp = make_shared<Ball>();
sp.reset(new Ball);//sp不再指向旧ball，引用计数-1，sp指向新的ball

访问类内成员变量，访问的是某个实例的成员，但是不希望使用该成员时实例本身被删除

struct Bar{ int i = 123;}
struct Foo{ Bar bar;}
int main(){
	shared_ptr<Foo> f  = make_shared<Foo>();
	cout << f.use_count（）<<endl; //prints 1
    
	shared_ptr<Bar>b (f, &(f->bar));
	cout << f.use_count() << endl; //prints 2
    
	cout << b->i << endl; //prints 123
}

注意使用智能指针时，不要手动delete

使用shared_ptr 需要额外的性能开销（引用计数）

unique_ptr

独享指针，独占某个资源的管理权

没有额外的性能开销

基本用法
#include <memory>
unique_ptr<int>UP = make_unique<int>(100);//申请
UP.reset();//释放

不支持复制操作！

class ball
{
    public:
	Ball(){
        cout <<"A ball appears."<<endl;
    }
    ~Ball(){
        cout <<"A ball disappears."<<endl
    }
    void Bounce(){
        cout <<"A ball jumps."<<endl;
    }

};

#include <memory>
#include <iostream>
using namespace std;
void func()
{
	cout <<"Now in func."<<endl;
	unique_ptr<Ball>up {make_unique<Ball>()}
	up->Bounce();
	cout <<"Before quiting func."<<endl;
}
int main(){
	cout <<"Now in main."<<endl;
	func();
	cout <<"End Executing func."<<endl;
}

/*执行结果
Now in main.
Now in func.
A ball appears.
A ball jumps.
Before quiting func.
A ball disappears.  //func执行结束后，up被销毁，执行析构，内存释放
End Executingfunc.
*/

unique_ptr被销毁时，其绑定的资源会自动释放

与普通指针一样的用法

auto ball = make_unique<Ball>();
ball->Bounce();
(*ball).Bounce();

与shared_ptr一样的用法

Ball*p = up->get();//获得资源的裸指针
up.reset();//释放资源 , up = nullptr
up.reset(new Ball{});//释放资源 ,并指向新的实例

其他用法

//1
Ball*ball = up.release();//解绑 返回资源的裸指针
delete ball;//
ball = nullptr;

//2
//up is a unique_ptr
up=nullptr;//会释放资源

不支持普通拷贝

unique_ptr<int>up1 = make_unique<int>(100);
unique_ptr<int> up2(up1);//error
up2 = up1;//error

//正确用法
unique_ptr<int>up1 = make_unique<int>(100);
unique_ptr<int>up2 (up1.release());//返回裸指针给up2初始化

unique_ptr<int>up2 = std::move(up1);//转移控制权

自定义分配函数 和释放函数

int*my_alloc(int v){
	cout <<"Allocating "<<v <<endl;
	return new int{v};
}
void my_dealloc(int *p){
	cout <<"Deallocating "<<*p <endl;
	delete p;
}
int main(){
    //需要在模板参数里面，声明自定义释放函数的类型
	unique_ptr<int, decltype(&my_dealloc)> cup {my_alloc(100), my_dealloc};
}

运行结果

Allocating 100
Deallocating 100

unique_ptr绑定释放函数是在编译期，避免了运行时绑定的时间损耗，删除函数的类型本身变成于unique_ptr实例的一部分

shared_ptr的自定义释放函数在运行时绑定

unique_ptr进阶用法

如何作为参数传递给函数

//错误写法
void pass_up(unique_ptr<int>up){
	cout <<"In pass_up: "<<*up <<endl;
}
void main(){
	auto up = make_unique<int>(123);
	pass_up(up);//编译错误
}

//正确写法1 直接传资源
void pass_upl(int& value){
	cout  <<"In pass_upl:" <<value  <<endl;
}
void main(){
	auto up = make_unique<int>(123);
	pass_up1(*up);//传递unique_ptr底下的资源
}

//正确写法2 传裸指针
void pass_up2(int*p){
	cout << "In pass_up2:" << *p  << endl;
}
void main(){
	auto up = make_unique<int>(123);
	pass_up2(up.get());
}

//正确写法3 传引用
void pass_up3(unique_ptr<int>&up){
	cout << "In pass_up3:"<< *up <<endl;
	up.reset();
}
void main(){
	auto up = make_unique<int>(123);
	pass_up3(up);
	if (up == nullptr)
		cout <<"up is reset."<<endl;
}
//正确写法4 move转移控制权
void pass_up4(unique_ptr<int>up){
	cout <<"In pass_up4:"<< *up <<endl;
}
void main(){
	auto up = make_unique<int>(123);
	pass_up4(move(up));//转移资源控制权
	if (up == nullptr)
        cout <<"up is moved."<<endl;
}

作为返回值

unique_ptr<int> return_uptr(int value){
	unique_ptr<int>up = make_unique<int>(value);
	return up; // 或者return move(up);
}

void main(){
	unique_ptr<int>up = return_uptr(321);
	cout << "up:" << *up << endl;
}

weak_ptr

weak_ptr是shared_ptr的伴侣

对资源的引用是非拥有式的，没有资源的管理权限，不能控制资源的释放

访问资源的时候需要创建临时shared_ptr

可以检查资源是否存在

为什么需要使用weak_ptr?

shared_ptr 在环形依赖的时候，仍造成内存泄漏

//环形依赖的情况
#include <iostream>
#include <memory>
#include <string>
using namespace std;

struct School;

struct Teacher{
    string name;
    int age;
    shared_ptr<School> school;
    ~Teacher(){
    	cout <<"Teacher Destructed."<<endl;
    }
};

struct School{
    string name;
    shared_ptr<Teacher> principal;//校长
    ~School(){
    	cout <<"School Destructed."<<endl;
    }
};

int main()
{
	auto principle = make_shared<Teacher>();
	auto university = make_shared<School>();
    
	principal->school  = university;
	university->principal =  principal;
    
	return 0;
}
//程序执行完成，不会调用析构
基本用法
#include <iostream>
#include <memory>
using namespace std;
int main()
{
	weak_ptr<int>wp;
	shared_ptr<int> sp = make_shared<int>(100);
	wp=sp;
    
    //使用weak_ptr访问对象
    auto resource = wp.lock() ;//资源未释放返回shared_ptr，资源已释放返回nullptr
    if (resource){
        cout <<"Number is "<< *resource <<endl;
    }else{
        cout <"wp is expired"<endl;
    }
}

另一种用法

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

std::weak_ptr<int>gw;

void observe()
{
	std:cout <<"gw.use_count()=="<< gw.use_count() <<";" ;
	//.we have to make a copy of shared pointer before usage:
	if (std:shared_ptr<int>spt = gw.lock())
	 	std:cout <<"*spt =="<<*spt <<'\n';
	else
		std:cout <<"gw is expired\n";
}
int main()
{
	{
		auto sp = std::make_shared<int>(42);
		gw = sp;
		observe();
	}
	observe();
}
//编译输出
//gw.use_count()==1; *spt ==42
//gw.use_count()==0; gw is expired

环形依赖的解决方法，

struct Teacher{
    string name;
    int age;
    weak_ptr<School> school;//改为weak_ptr即可
    ~Teacher(){
    	cout <<"Teacher Destructed."<<endl;
    }
};

将School和Teacher类中的指针全部改为weak_ptr类型也行

shared_ptr是拥有一个物体的控制权，而weak_ptr只是一个观察者。如果你只需要观察物体而不是控制物体的分配、删除，那么就用weak_ptr，反之如果你想要拥有物体的控制权，用shared_ptr

注释：

上述资料为个人学习总结笔记，学习资源来自 b站 HexUp

7eeliamn
关注
专栏目录
c++智能指针详解
bitcarmanlee的博客
05-18 3万+
1.什么是智能指针 从比较简单的层面来看，智能指针是RAII(Resource Acquisition Is Initialization，资源获取即初始化)机制对普通指针进行的一层封装。这样使得智能指针的行为动作像一个指针，本质上却是一个对象，这样可以方便管理一个对象的生命周期。 在c++中，智能指针一共定义了4种： auto_ptr、unique_ptr、shared_ptr 和 weak_ptr。其中，auto_ptr 在 C++11已被摒弃，在C++17中已经移除不可用。 2.原始指针的问题 原始指
C++智能指针详解
qq_61635026的博客
10-02 2063
智能指针是存储指向动态分配（堆）对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像C++的内置指针。智能指针在面对异常的时候格外有用，因为他们能够确保正确的销毁动态分配的对象。他们也可以用于跟踪被多用户共享的动态分配对象。下面我们先分析一下下面这段程序有没有什么内存方面的问题？ 关于内存泄漏见文章【C++ 内存管理】RAII（Resource Acquisition Is Initialization），也称为 “资源获取就是初始化” ，是一种利用对象生命周期来控制程序资源（如内存
C++智能指针-unique-ptr智能指针详解.pdf
02-27
《C++智能指针——unique_ptr智能指针详解》 智能指针是C++中用于自动管理动态分配内存的一种工具，它可以确保在适当的时候自动释放内存，从而避免内存泄漏的问题。其中，`unique_ptr`是一种特殊的智能指针，它拥有...
C++智能指针详解abc
08-24
C++智能指针详解 标题解释 "C++智能指针详解abc"这一标题表明，本文将详细介绍C++中的智能指针机制，包括其概述、原理、使用方法和结论等方面。 描述解释 "C++智能指针详解abc"这一描述表明，本文将对C++中的智能...
Type-C PD诱骗取电快充协议芯片 支持PD 5V、9V、12V、15V、20V电压
xcx003的博客
11-02 629
XSP01A是一款专为Type-C接口设计的取电诱骗协议芯片，它它集成了先进的电源管理和协议控制功能，旨在为用户提供高效、安全、稳定的充电体验。该芯片集成USB Power Delivery (PD) 3.0/2.0快充协议，支持从手机充电器/车充等电源上取电给产品供电。支持最大功率100W给设备安全快速供电。综上所述，XSP01A诱骗取电协议芯片以其高效、安全、稳定的充电性能以及广泛的设备兼容性和应用场景，正在逐步改变着我们的充电体验和设备电源管理方式。
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 315
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
链表交集相关算法题|AB链表公共元素生成链表C|AB链表交集存放于A|连续子序列|相交链表求交点位置(C)
ChoSeitaku的博客
11-04 1108
表A，B都有序，可从第一个元素起依次比较A、B两表的元素，若元素值不等，则值小的值往后移，若元素值相等，则创建一个值等于两节点的元素值的新节点，使用尾插法插入到新的链表中，并将两个原表指针后移一位，直到其中一个链表遍历到表尾。一个工作指针cura用来遍历链表A，一个工作指针curb用来遍历链表B，一个工作指针curc用来建立链表C，一个指针new用来创建共同节点的新节点尾插到C链表上。循环结束后，如果curb指向NULL，表示链表B的curb都等于对应的cura，链表B是链表A的连续子序列。
C++编程法则365天一天一条（344）理解std::optional的设计初衷
二进制君
11-02 101
的设计初衷是为了解决处理可选值时的安全性和清晰性问题，提供一种简洁、易用的方式来表示和管理可能不存在的值。通过引入，C++ 提供了一个更现代化的替代方案，减少了使用传统空指针和特定标记值所带来的复杂性和错误风险。
每日OJ题_牛客_排序子序列_模拟_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-02 372
每日OJ题_牛客_排序子序列_模拟_C++_Java（根据题意用指针模拟即可）
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
weixin_66461496的博客
11-02 1048
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
C++11|std::move和std::forward的区别
mooridy的博客
11-05 360
std::move和是C++11中引入的两个模板函数，它们在C++的类型推导和完美转发中扮演着重要的角色。
C++ -- 模板进阶
zy1215058242的博客
11-02 838
一个程序/项目由若干源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生。增强了代码的灵活性。模板会导致会导致代码代码膨胀问题，也会导致编译时间变长。出现模板编译错误时，错误信息非常凌乱，不易定位错误。
c++之 stack(栈)和queue(队列)
2301_80028974的博客
11-04 842
文档stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行 元素的插入与提取操作。stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定 的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器， 默认情况下使用deque。
【Effective C++】阅读笔记5
最新发布
gma999的博客
11-07 785
Effective C++ 面向对象和模板相关章节
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值