C++ 智能指针

已于 2022-02-24 11:26:22 修改
阅读量548 收藏
点赞数
分类专栏： C++ 文章标签： c++ 智能指针 shared_ptr RAII unique_ptr
于 2022-02-24 10:38:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53946312/article/details/123059965
版权

文章目录

内存泄漏

什么是内存泄漏：
内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等，出现内存泄漏会导致响应越来越慢，最终卡死。

内存泄漏的分类

  • 堆内存泄漏(Heap leak) ：堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc /new等从堆中分配的一块内存， 用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那 么以后这部分空间将无法再被使用，就会产生Heap Leak。
  • 系统资源泄漏指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

如何避免内存泄漏

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

    总结一下:
    内存泄漏非常常见，解决方案分为两种：
    1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具

智能指针的使用及原理

RAII

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

#pragma once

template <class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}
	~SmartPtr()
	{
		cout << "delete# " << _ptr << endl;
		delete _ptr;
	}
private:
	T* _ptr;

};

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include "SmartPtr.h"
#
using namespace std;
int div()throw(invalid_argument)
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
	{
		throw invalid_argument("除0错误");
		return a / b;
	}

}
void f1()
{
	int* p = new int;
	SmartPtr<int> Sp(p);
	cout << div() << endl;
	//delete p;
}
int main()
{
	try
	{
		f1();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

在这里插入图片描述
智能指针的原理：
1、RAII特性
2、重载operator*和operator->，具有像指针一样的行为

template <class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}
	~SmartPtr()
	{
		cout << "delete# " << _ptr << endl;
		delete _ptr;
	}
	//可以像指针一样使用
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;

};

auto_ptr

auto_ptr的实现原理：管理权转移的思想,保证只有一个对象在管理资源同时导致拷贝后原对象悬空

namespace app
{
	template <class T>
	class auto_ptr
	{//C++98---管理权转移,保证只有一个对象在管理资源
	public:
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}
		~auto_ptr()
		{
			if (_ptr != nullptr)
			{
				cout << "delete# " << _ptr << endl;
				delete _ptr;
				_ptr == nullptr;
			}

		}
		//管理权转移
		//ap2(ap1)
		auto_ptr(auto_ptr<T>& ap)
			:_ptr(ap._ptr)
		{
			ap._ptr = nullptr;
		}
		//赋值
		//ap1 = ap3 ap1 = ap1
		auto_ptr<T>& operator=(auto_ptr<T>& ap)
		{
			if (this != &ap)
			{
				delete _ptr;
				_ptr = ap._ptr;
				ap._ptr = nullptr;
			}
			return *this;
		}
		//可以像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;

	};
}


int main()
{
	app::auto_ptr<int> ap1(new int);//有拷贝问题
	app::auto_ptr<int> ap2(ap1);
	//*ap1 = 10;出错
	//*ap2 = 20;
	return 0;
}

在这里插入图片描述

unique_ptr

unique_ptr的实现原理：简单粗暴的防拷贝
boost中的scoped_ptr

namespace un
{
	template <class T>
	class unique_ptr
	{//简单粗暴的解决拷贝：禁止拷贝
	public:
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}
		~unique_ptr()
		{
			
				cout << "delete# " << _ptr << endl;
				delete _ptr;
			

		}

		//可以像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		unique_ptr(const unique_ptr<T>&) = delete;
		unique_ptr<T>operator=(const unique_ptr<T>&) = delete;
	private:
		T* _ptr;

	};
}

shared_ptr

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。
就是boost中的dhared_ptr—缺陷：循环引用

  • shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
  • 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
  • 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
  • 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针
template <class T>
	class shared_ptr
	{//简单粗暴的解决拷贝：禁止拷贝
	private:
		void Addref()
		{
			_mtx->lock();
			++(*_count);
			_mtx->unlock();
		}
		void Releaseref()
		{
			_mtx->lock();
			bool flag = false;
			if (--(*_count) == 0)
			{
				cout << "delete: " << _ptr << endl;
				delete _ptr;
				delete _count;
				flag = true;
			}
			_mtx->unlock();
			if (flag == true)
			{
				delete _mtx;
			}
		}
	public:
		shared_ptr(T* ptr)
			:_ptr(ptr)
			, _count(new int(1))
			, _mtx(new mutex)
		{}
		~shared_ptr()
		{
			Releaseref();
		}
		
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _count(sp._count)
			, _mtx(sp._mtx)
		{
			Addref();
		}
		//sp1 = sp2 sp1 = sp1
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				Releaseref();
				_count = sp._count;
				_ptr = sp._ptr;
				_mtx = sp._mtx;
				Addref();
			}
			return *this;
		}

		//可以像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		int use_count()
		{
			return *_count;
		}
	
	private:
		T* _ptr;
		int* _count;
		mutex* _mtx;//解决线程安全问题
	};
weak_ptr

就是boost中的weak_ptr主要用来解决shared_ptr的循环引用问题

template<class T>
	class weak_ptr
	{
		//不参加资源管理，不增加shared_ptr管理资源的引用计数，可以向指针一样引用
	public:
		weak_ptr()
			:_ptr(nullptr)
		{}
		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp.get())
		{}

		weak_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			return *this;
		}
		// 可以像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
删除器

解决不是new出来的对象通过智能指针管理

template<class T, class D = Delete<T>>
	class shared_ptr
	{
	private:
		void AddRef()
		{
			_pmutex->lock();
			++(*_pcount);
			_pmutex->unlock();
		}

		void ReleaseRef()
		{
			_pmutex->lock();
			bool flag = false;
			if (--(*_pcount) == 0)
			{
				if (_ptr)
				{
					cout << "delete:" << _ptr << endl;
					//delete _ptr;
					_del(_ptr);
				}

				delete _pcount;
				flag = true;
			}
			_pmutex->unlock();

			if (flag == true)
			{
				delete _pmutex;
			}
		}
	public:
		// RAII
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
			, _pmutex(new mutex)
		{}

		shared_ptr(T* ptr, D del)
			: _ptr(ptr)
			, _pcount(new int(1))
			, _pmutex(new mutex)
			, _del(del)
		{}

		~shared_ptr()
		{
			ReleaseRef();
		}

		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
			, _pmutex(sp._pmutex)
		{
			AddRef();
		}

		// sp1 = sp1
		// sp1 = sp2
		// sp3 = sp1;
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				ReleaseRef();

				_pcount = sp._pcount;
				_ptr = sp._ptr;
				_pmutex = sp._pmutex;

				AddRef();
			}

			return *this;
		}


		// 可以像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}

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

		int use_count()
		{
			return *_pcount;
		}

		T* get() const
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pcount;
		mutex* _pmutex;
		D _del;
	};
定制删除器
	//定制删除器---删除器控制释放资源的方式
	template<class T>
	struct DelArr
	{
		void operator()(const T* ptr)
		{
			cout << "delete[]: " << ptr << endl;
			delete[] ptr;
		}		
	};
	// 定制删除器
template<class T>
class DelRef
{
public:
	void operator()(T*& ptr)
	{
		if (ptr)
		{
			delete ptr;
			ptr = nullptr;
		}
	}
};
 
template<class T>
class Free
{
public:
	void operator()(T*& ptr)
	{
		if (ptr)
		{
			free(ptr);
			ptr = nullptr;
		}
	}
};
 
class FClose
{
public:
	void operator()(FILE*& pf)
	{
		if (pf)
		{
			fclose(pf);
			pf = nullptr;
		}
	}
};
qnbk
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++智能指针
Edward2022的博客
03-22 791
unique_ptr、shared_ptr、weak_ptr
C++ 智能指针 - 全部用法详解
热门推荐
cpp_learner的博客
08-02 7万+
血的教训？不学智能指针，本人丢了一份工作。
C++智能指针详解
qq_61635026的博客
10-02 1747
智能指针是存储指向动态分配（堆）对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像C++的内置指针。智能指针在面对异常的时候格外有用，因为他们能够确保正确的销毁动态分配的对象。他们也可以用于跟踪被多用户共享的动态分配对象。下面我们先分析一下下面这段程序有没有什么内存方面的问题？ 关于内存泄漏见文章【C++ 内存管理】RAII（Resource Acquisition Is Initialization），也称为 “资源获取就是初始化” ，是一种利用对象生命周期来控制程序资源（如内存
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++智能指针基础用法详解
mahuifa的博客
04-21 1105
智能指针是C++中用于管理动态分配资源的强大工具，通过正确使用智能指针，可以显著减少内存泄漏的可能性，并提高代码的安全性和可维护性。
c++ 智能指针原理
m0_60697583的博客
03-06 1222
智能指针是 C++ 中的一种特殊指针，它能够自动管理动态分配的内存资源，避免内存泄漏和悬空指针等问题。
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
c++智能指针
08-15
C++中的智能指针是一种特殊的类模板，用于自动化内存管理，以帮助避免诸如内存泄漏、重复释放等问题。在C++11及以后的版本中，最常用的智能指针类型包括std::shared_ptr、std::unique_ptr和std::weak_ptr。 在讨论...
C++智能指针知识学习笔记
最新发布
08-20
C++智能指针知识学习笔记
C++二叉树进阶
weixin_53946312的博客
10-24 2238
二叉树进阶二叉搜索树二叉搜索树概念二级目录三级目录 二叉搜索树 二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 时间复杂度：O(N)，只有当树的形状接近完全二叉树或者满二叉树，才能达到 logN 搜索二叉树延伸：AVLTree 红黑树(对搜索二叉树左右高度提出要求，非常接近完全二叉树，效率可达到 O(logN))
C++ 红黑树
weixin_53946312的博客
01-28 1506
红黑树
C++-- 二叉树的层序遍历
weixin_53946312的博客
10-24 1435
二叉树的层序遍历 题目要求： 题目来源：力扣 class Solution { public: vector<vector<int>> levelOrder(TreeNode* root) { if(root == nullptr) { return vector<vector<int>> (); } queue<TreeNode*> q;
把字符串转换成整数(C++)
weixin_53946312的博客
07-27 1155
把字符串转化成整数 题目描述： 思路： 要考虑正负数 要考虑数据是否溢出 题目来源：牛客 class Solution { public: int StrToInt(string str) { int len=str.size(); int flag=1; if(len==0) return 0; const char *cstr = str.c_str(); if(cstr == NULL)
C++ AVL树
weixin_53946312的博客
01-27 1131
AVL树底层结构AVL树(高度平衡搜索二叉树)AVL树的插入四种旋转右单旋左单旋右左双旋左右双旋AVL实现代码AVL树的性能 底层结构 map/set/multimap/multiset等这些容器其底层都是按照二叉搜索树来实现的但是二叉搜索树有其自身的缺陷,eg:往树中插入的元素有序或接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N),因此map,set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来来实现。 AVL树(高度平衡搜索二叉树) 二叉搜索树虽然可以缩短查找的效率，但如
C++ map和set
weixin_53946312的博客
01-27 1099
map和set
C++ 两个数组的交集
weixin_53946312的博客
01-28 1036
两个数组的交集 题目来源：leetcode class Solution { public: vector<int> intersection(vector<int>& nums1, vector<int>& nums2) { //用unordered_set对num2中的元素去重 unordered_set<int> s2; for(auto e: nums2) {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值