【C++进阶】智能指针

已于 2024-08-04 17:39:41 修改
阅读量576 收藏 21
点赞数 19
分类专栏： 【c++从初阶到进阶】C++熟悉之路 文章标签： c++ java 数据库
于 2024-08-04 11:21:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78611726/article/details/140884540
版权

目录

1.为什么需要智能指针

分析下面代码，是否有什么内存问题？？？

void Func()
{
	int* p1 = new int[10];
	int* p2 = nullptr;
	try
	{
		p2 = new int[20];
		try
		{
			int len, time;
			cin >> len >> time;
			cout << Division(len, time) << endl; // throw
		}
		catch (...)
		{
			delete[] p1;
			cout << "delete:" << p1 << endl;

			delete[] p2;
			cout << "delete:" << p2 << endl;

			throw;  // 捕获什么抛出什么
		}
	}
	catch (...)
	{
		delete[] p1;
		cout << "delete:" << p1 << endl;

		throw;
	}

	delete[] p1;
	cout << "delete:" << p1 << endl;

	delete[] p2;
	cout << "delete:" << p2 << endl;
}

当然上面乍一看代码是没问题的，但如果我们在p1申请内存时就抛异常呢，程序被异常终止，那后面的代码就通通跑不到了啊！！！，内存没有被释放，终究会造成内存泄漏！！！

2.内存泄漏

2.1 什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

2.2 内存泄漏分类

C/C++一般我们只关心两方面的内存泄漏问题

堆内存泄漏

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc /
new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

2.3 如何避免内存泄漏

  1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
  2. 采用RAII思想或者智能指针来管理资源。
  3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
  4. 出问题了使用内存泄漏工具检测。不过很多工具都不够靠谱，或者收费昂贵。

总结一下:
内存泄漏非常常见，解决方案分为两种：

  1. 事前预防型。如智能指针等。
  2. 事后查错型。如泄漏检测工具。

3.智能指针的使用及原理

3.1 RAII

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托给了一个对象。这种做法有两大好处：

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效。
template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

	~SmartPtr()
	{
		delete[] _ptr;
		cout << "delete:" << _ptr << endl;
	}

	T* get()
	{
		return _ptr;
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}

	T& operator[](size_t i)
	{
		return _ptr[i];
	}
private:
	T* _ptr;
};

double Division(int a, int b)
{
	if (b == 0)
		throw invalid_argument("除0错误");

	return a / b;
}
void Func()
{
	SmartPtr<int> sp1(new int[10]);
	SmartPtr<int> sp2(new int[20]);

	int len, time;
	cin >> len >> time;
	cout << Division(len, time) << endl;
}

int main()
{
	//SmartPtr sp1(new int[10]);

	try
	{
		Func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "未知异常" << endl;
	}

	return 0;
}

3.2 智能指针的原理

上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用。

总结一下智能指针的原理：

  1. RAII特性
  2. 重载operator*和opertaor->，具有像指针一样的行为。

3.3 std::auto_ptr

auto_ptr文档介绍
auto_ptr是C++98就提供的比较老的智能指针了，这样的指针指针一经出现就使得众公司纷纷下达禁令，严禁使用该智能指针，这是为什么？？
懂得auto_ptr的原理你就明白了！！！
auto_ptr的实现原理：管理权转移的思想！！！

int main()
{
	auto_ptr<int> sp1(new int(1));
	// C++98 转移管理权，sp1对象悬空
	auto_ptr<int> sp2(sp1);

	*sp1 += 1;

	return 0;
}

在这里插入图片描述
内部其实就是在拷贝构造时，把sp1置空，sp2直接指向sp1所指向的内容！！！
表面看没问题啊！！！，也没发生内存泄漏的？？？
你看sp1拷贝构造给sp2，sp1是局部变量，是左值，我们只有对右值即将亡值才会放心的把管理权转移，而左值是不可以的，万一左值被解引用了呢？？？

3.4 std::unique_ptr

unique_ptr文档介绍
所以C++11又提供了一系列更靠谱的智能指针！！！
第一个是unique_ptr。unique_ptr实现原理简单除暴，直接把拷贝构造，赋值重载给屏蔽掉，使用了delete！！！

unique_ptr(const unique_ptr<T>&sp) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>&sp) = delete;

class A
{
public:
	A(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{}

	~A()
	{
		cout << "~A()" << endl;
	}
	//private:
	int _a1 = 1;
	int _a2 = 1;
};

int main()
{
	unique_ptr<A> sp1(new A(1, 1));
	//unique_ptr<A> sp2(sp1);
	A* p = sp1.get();
	cout << p << endl;

	//sp1->_a1++;
	//sp1->_a2++;

	/*sp1[1]._a1++;
	sp1[1]._a2++;*/

	return 0;
}

3.5 std::shared_ptr

shared_ptr文档介绍
C++11shared_ptr开始提供更靠谱的并且支持拷贝的shared_ptr。

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。例如：
放学时，老师都会提醒最后一个走的同学记得关灯，记得把门锁一下等等。

  1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
  2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
  3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
  4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

代码模拟实现：

// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
#pragma once
#include<atomic>
template<class T>
class SharedPtr
{
public:
	SharedPtr(T* ptr)
		:_ptr(ptr)
		,_pcount(new atomic<int>(1))
	{}
	//spt2(spt1)
	SharedPtr(const SharedPtr<T>& sp)
		:_ptr(sp._ptr)
		,_pcount(sp._pcount)
	{
		(*_pcount)++;
	}
	//spt2 = spt1
	const SharedPtr<T>& operator=(const SharedPtr<T>& sp)
	{
		if (_ptr != sp._ptr)//防止sp2与sp1指向的是相同的资源，例如sp1=sp1
		{
			this->release();//释放自己的资源接受对方的资源

			_ptr = sp._ptr;
			_pcount = sp._pcount;
			(*_pcount)++;
		}
		return *this;
	}
	void release()
	{
		if (--(*_pcount) == 0)
		{
			//由最后一个管理资源的释放
			delete _ptr;
			delete _pcount;
		}
	}
	~SharedPtr()
	{
		release();
	}
	int use_count()
	{
		return *_pcount;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
	atomic<int>* _pcount;
};

使用:

//库中的使用
int main()
{
	shared_ptr<A> sp1(new A(1, 1));
	shared_ptr<A> sp2(sp1);

	shared_ptr<A> sp3 = make_shared<A>(1, 1);

	cout << sp1.use_count() << endl;
	{
		shared_ptr<A> sp3(sp1);
		cout << sp1.use_count() << endl;
	}

	cout << sp1.use_count() << endl;


	return 0;
}
//模拟实现代码测试
#include"SharedPtr.h"

int main()
{
	SharedPtr<A> sp1(new A(1, 1));
	SharedPtr<A> sp2(sp1);

	cout << sp1.use_count() << endl;

	SharedPtr<A> sp3(new A(2, 2));
	SharedPtr<A> sp4(sp3);
	SharedPtr<A> sp5(sp4);
	cout << sp3.use_count() << endl;

	sp1 = sp3;
	sp2 = sp3;

	SharedPtr<A> sp6(new A(3, 3));
	sp6 = sp6;
	sp3 = sp4;

	return 0;
}

shared_ptr的线程安全问题
通过下面的程序我们来测试shared_ptr的线程安全问题。需要注意的是shared_ptr的线程安全分为两方面：

  1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或–，这个操作不是原子的，引用计数原来是++了两次，可能还是2.这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数++、–是需要加锁的，也就是说引用计数的操作是线程安全的。
  2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。
#include<mutex>
#include<list>
#include"SharedPtr.h"
mutex mtx;

// 智能指针对象本身拷贝析构是线程安全的
// 底层引用计数加减是线程安全的
// 指向的资源访问不是线程安全的
void func(SharedPtr<list<int>> sp, int n)
{
	cout << sp.use_count() << endl;

	for (int i = 0; i < n; i++)
	{
		SharedPtr<list<int>> copy1(sp);
		SharedPtr<list<int>> copy2(sp);
		SharedPtr<list<int>> copy3(sp);

		mtx.lock();
		sp->emplace_back(i);
		mtx.unlock();
	}
}

int main()
{
	SharedPtr<list<int>> sp1(new list<int>);
	cout << sp1.use_count() << endl;

	thread t1(func, sp1, 1000000);
	thread t2(func, sp1, 2000000);

	t1.join();
	t2.join();

	cout << sp1->size() << endl;
	cout << sp1.use_count() << endl;

	return 0;
}

循环引用
shared_ptr是有缺陷的，当shared_ptr出现循环引用时会造成内存泄漏，所以shared_ptr是有缺陷与局限性的，那什么是循环引用呢？
在这里插入图片描述

代码：

struct Node
{
	shared_ptr<Node> _next;
	shared_ptr<Node> _prev; 


	int _val;

	~Node()
	{
		cout << "~Node()" << endl;
	}
};


int main()
{
	shared_ptr<Node> p1(new Node);
	shared_ptr<Node> p2(new Node);

	cout << p1.use_count() << endl;
	cout << p2.use_count() << endl;

	p1->_next = p2;
	p2->_prev = p1;

	cout << p1.use_count() << endl;
	cout << p2.use_count() << endl;

	return 0;
}

循环引用分析：

  1. p1和p2两个智能指针对象指向两个节点，我们不需要delete，引用计数为1。
  2. p1的_next指向p2，p2的_prev指向p1,引用计数变为2。
  3. 程序结束时p1,p2析构，引用计数减到1，但引用计数虽–了，p1仍指向p2，p2仍指向p1没有释放。
  4. 也就是说_next释放了，p1才会释放，_prev释放了p2才会释放。
  5. 但是_next属于p1的成员，_prev属于p2的成员，p1,p2释放了_next,_prev才会释放p1p2各自管理自己的成员，所以造成了循环引用，谁也不会释放！！！

3.6 std::weak_ptr

weak_ptr不能单独管理资源，必须配合shared_ptr一块使用，解决shared_ptr中存在的循环引用问题
所以就需要有weak_ptr,weak_ptr可以完美的解决循环引用的问题。
原理就是：p1,p2的_next,_prev在指向时，不会增加p1,p2的引用计数！！！
weak_ptr的构造可以传入一个shared_ptr对象
在这里插入图片描述
代码：

struct Node
{
	weak_ptr<Node> _next;
	weak_ptr<Node> _prev;
	int _val;

	~Node()
	{
		cout << "~Node()" << endl;
	}
};


int main()
{
	shared_ptr<Node> p1 = make_shared<Node>();
	shared_ptr<Node> p2 = make_shared<Node>();

	cout << p1.use_count() << endl;
	cout << p2.use_count() << endl;

	p1->_next = p2;
	p2->_prev = p1;

	cout << p1.use_count() << endl;
	cout << p2.use_count() << endl;

	cout << p1->_next.use_count() << endl;
	cout << p2->_prev.use_count() << endl;



	return 0;
}

Node中的_next,_prev的指向不会影响p1,p2的引用计数。

3.7 智能指针的删除器

如果不是new出来的对象如何通过智能指针管理呢？其实shared_ptr设计了一个删除器来解决这
个问题。（了解）

class A
{
public:
	A() {};
	A(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{}

	~A()
	{
		cout << "~A()" << endl;
	}
	//private:
	int _a1 = 1;
	int _a2 = 1;
};
template<class T>
struct FreeFunc {
	void operator()(T* ptr)
	{
		cout << "free:" << ptr << endl;
		free(ptr);
	}
};
// 定制删除器
int main()
{
	//std::shared_ptr<A[]> sp1(new A[10]);
	shared_ptr<A> sp1(new A[10], [](A* ptr) {delete[] ptr; });
	shared_ptr<int> sp2((int*)malloc(4), FreeFunc<int>());
	shared_ptr<FILE> sp3(fopen("test.txt", "w"), [](FILE* ptr) {fclose(ptr); });

	shared_ptr<A> sp4(new A);

	return 0;
}
花影随风_
关注
  • 19
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++进阶：智能指针
碧瑶的博客呀
10-02 248
为什么需要智能指针 智能指针：管理指针，自动释放资源 智能指针的使用及原理 例如： template <class T> class Smartptr { public: Smartptr(T* ptr = nullptr) :_ptr(ptr) {} ~Smartptr() { if (_ptr) delete[]_ptr; } T& opera...
C++进阶：智能指针，写时拷贝技术
凯凯在此
07-12 1343
文章目录1. 智能指针 auto_ptr1.1 auto_ptr的原理1.2 内存检测工具的使用1.3 数组指针的释放1.4 赋值操作的问题2. 智能指针 unique_ptr3. 智能指针 scoped_ptr4. 智能指针 shared_ptr4.1 shared_ptr的原理4.2 数组指针的释放5. 智能指针 weak_ptr 指针的危害 指针未初始化 野指针 内存泄漏 1. 智能指针 auto_ptr 1.1 auto_ptr的原理 作用： 对作用域内的动态分配对象的自动释放 #inclu
C++进阶 智能指针
小萌新的博客
08-09 780
介绍了C++中的智能指针
C++进阶--C++11智能指针
sushang的博客
02-07 1577
智能指针不是指针，是一个管理指针的类，用来存储指向动态分配对象的指针，负责自动释放动态分配的对象，防止堆内存泄漏。动态分配的资源，交给一个类对象去管理，当类对象生命周期结束时，自动调用析构函数释放资源。RAII是resource acquisition is initialization的缩写，意为“资源获取即初始化”。它是 C++ 之父 Bjarne Stroustrup 提出的设计理念，其核心是把资源和对象的生命周期绑定，对象创建获取资源，对象销毁释放资源。
【C++进阶】：智能指针
m0_73790767的博客
10-11 115
关于智能指针的讲解,auto_ptr,unique_ptr,share_ptr以及循环引用的解析
C++进阶 —— 智能指针
NapoleonCoder的博客
12-19 986
智能指针，RAII；
C++进阶-智能指针
最新发布
weixin_64423718的博客
08-13 379
什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。// 1.内存申请了忘记释放// 2.异常安全问题Func();// 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
C++进阶：异常和智能指针
yourfriendyo的博客
09-07 465
实际项目中不可随便抛任意类型的异常，这样会增加处理难度。很多公司都会定义自己的异常类体系进行规范的异常管理。实际工程中也都是自定义异常类体系，用父类对象捕获子类对象，这非常实用。", 101);//...//...
C++进阶——智能指针（C++11）
m0_73093743的博客
01-26 1209
所以，总的来说，如果我们要用智能指针的话，一般用 shared_ptr 和 weak_ptr 搭配用就可以解决程序因为抛异常而导致执行流乱跳，进而造成内存泄漏等问题了。
C++进阶，迈向C++高级世界
10-12
C++进阶，迈向C++高级世界 C++是一种功能强大且灵活的编程语言，它提供了大量的语法糖，对开发者来说，这些语法糖可以提高编码效率、减少错误和提高代码可读性。但是，对于初学者来说，C++可能是一个很陌生的领域，...
C++进阶重点知识精讲1-202110231
08-03
在C++编程中，智能指针是用于管理动态分配内存的一种工具，特别是在C++11标准及以后的版本中引入的智能指针极大地...这些知识点都是C++进阶学习中的重要组成部分，理解并掌握它们对于编写高效、安全的C++代码至关重要。
C++进阶课程讲义_v1.0.4.pdf
01-08
再者，C++11及其后续标准引入的新特性也是进阶课程的重要内容，例如lambda表达式、右值引用、类型推断（auto关键字）、move语义和智能指针等。Lambda表达式使得匿名函数的使用更加方便，右值引用和move语义则提高了...
C++高手进阶讲义
10-19
这份讲义涵盖了C++11到C++20的最新特性，包括但不限于语言优化、模板元编程、智能指针、并发编程、以及现代C++的设计模式。 1. **C++11新特性**： - **自动类型推断（Auto）**：使用`auto`关键字，编译器可以自动...
C++菜鸟进阶
07-26
随着对C++基础的熟练掌握，可以进一步探索高级主题，如智能指针、模板元编程、并发编程等，同时关注C++社区动态，如参加技术论坛、阅读专业书籍、参与开源项目，不断提升自己的技术水平。 总之，C++菜鸟进阶之路既...
C++笔记5•内存管理•
qq_64446190的博客
08-12 1002
内存管理
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 515
c++ error: ‘*’ does not name a type； did you mean ‘**’?
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 405
STL中的迭代器失效（vector为例）
C语言一维数组(含数组二分查找)
hdxbufcbjuhg的博客
08-09 1214
在⼀个升序的数组中查找指定的数字n，很容易想到的⽅法就是遍历数组，但是这种⽅法效率⽐较低。比如我们之前写的猜数字游戏，会生成一个随机数来让玩家猜，范围是1~100，那玩家会从1开始一个一个猜吗，不会吧，那样就太慢了，我们一般会从整体的一半开始猜，比如猜50，告诉你大了还是小了，这样只需要一步就可以排除庞大数字中的一半，比如假设猜1 ~ 10000，猜5000后就可以知道猜大了还是小了，直接排除了5000个数字，效率很快，这就是⼆分查找，也叫折半查找。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

花影随风_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值