智能指针

最新推荐文章于 2023-02-18 17:30:22 发布
最新推荐文章于 2023-02-18 17:30:22 发布
阅读量715 收藏
点赞数 1
分类专栏： C++ 文章标签： 智能指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IT_iverson/article/details/78091366
版权
本文深入探讨了智能指针的概念及其实现方式，包括解决内存泄漏问题的多种智能指针类型如Auto_ptr、Scoped_ptr、Scoped_array、Shared_ptr、Shared_array等，并详细分析了它们的工作原理及其优缺点。
摘要由CSDN通过智能技术生成

一.为什么会有智能指针

智能指针其实是解决不经意间内存泄露的一个机制~

首先看下面的代码：

bool connectserver()
{
	cout << "链接服务" << endl;
	return rand() % 5 == 0;
}
void pushmail()
{
	cout << "链接成功" << endl;
	cout << "发送邮件" << endl;
	if (rand() % 2 == 0)
	{
		throw 1;
	}
}
void fun()
{
	char *p= new char[1024 * 1024];
	if (!connectserver())
	{
		cout << "链接数据库失败" << endl;
		delete[]p;
		return;
	}
	pushmail();
	delete[]p;
}
int main()
{
	while (1)
	{
		try
		{
			fun();
		}
		catch (int e)
		{
			cout << "抛出异常" << endl;
		}
			Sleep(1000);
	}
	system("pause");
	return 0;
}


对于上述代码，执行过程乱跳，很容易造成内存泄露;


二.怎么解决呢？

首先要知道RAII：


如下解决代码

template<typename T>
class Auto_ptr
{
private:
	T *_ptr;
public:
	Auto_ptr(T *ptr)
		:_ptr(ptr)//初始化获取资源
	{}
	~Auto_ptr()
	{
		delete[]_ptr;
		_ptr = NULL;
	}
};
bool connectserver()
{
	cout << "链接服务" << endl;
	return rand() % 5 == 0;
}
void pushmail()
{
	cout << "链接成功" << endl;
	cout << "发送邮件" << endl;
}
void fun()
{
	Auto_ptr<char> ap1 = new char[1024 * 1024];
	if (!connectserver())
	{
		cout << "链接数据库失败" << endl;
		return;
	}
	pushmail();
}
int main()
{
	while (1)
	{
			fun();
			Sleep(1000);
	}
	system("pause");
	return 0;
}

看如下代码

template<typename T>
class Auto_ptr
{
private:
	T *_ptr;
public:
	Auto_ptr(T *ptr)
		:_ptr(ptr)//初始化获取资源
	{}
	~Auto_ptr()
	{
		delete[]_ptr;
		_ptr = NULL;
	}
};
这个存在的问题，既然是智能指针就需要有指针的功能，需要operator*和operator->

重载后的代码

template<typename T>
class Auto_ptr
{
private:
	T *_ptr;
public:
	Auto_ptr(T *ptr)//RAII不等于智能指针，智能指针只是RAII的一种思想的实现
		:_ptr(ptr)//初始化获取资源
	{}
	~Auto_ptr()
	{
		delete[]_ptr;
		_ptr = NULL;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
};

除了重载那两个符号的问题还有什么问题？

void test()
{
	int *p = new int(10);
	Auto_ptr<int> ap1(p);
	Auto_ptr<int> ap2(ap1);
}


程序崩溃，因为其指向一块内存，注意和string的区别，智能指针只是帮忙管理，不进行操作的

通过的初始化崩溃问题引出

c98之前人们解决的方案是-----》权限管理，但是其也是带有严重的缺陷的解决问题

接下来给出权限转移的代码，这就需要我们自己来写拷贝构造函数了，代码如下

template<typename T>
class Auto_ptr
{
private:
	T *_ptr;
public:
	Auto_ptr(T *ptr)//RAII不等于智能指针，智能指针只是RAII的一种思想的实现
		:_ptr(ptr)//初始化获取资源
	{}
	~Auto_ptr()
	{
		delete[]_ptr;
		_ptr = NULL;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T operator->()
	{
		return _ptr;
	}
	Auto_ptr(Auto_ptr<T>& p)//拷贝构造函数,拷贝完就释放原来的空间~
		:_ptr(p._ptr)
	{
		p._ptr = NULL;
	}
};

除此之外还有赋值运算符重载函数，不然赋值的时候还会崩溃

代码如下

template<typename T>
class Auto_ptr
{
private:
	T *_ptr;
public:
	Auto_ptr(T *ptr)//RAII不等于智能指针，智能指针只是RAII的一种思想的实现
		:_ptr(ptr)//初始化获取资源
	{}
	~Auto_ptr()
	{
		delete[]_ptr;
		_ptr = NULL;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T operator->()
	{
		return _ptr;
	}
	Auto_ptr(Auto_ptr<T>& p)//拷贝构造函数,拷贝完就释放原来的空间~
		:_ptr(p._ptr)
	{
		p._ptr = NULL;
	}
	   Auto_ptr<T>& operator=(Auto_ptr<T>& ap)
	{
			if (this != &ap)
			{
				if (_ptr)//先释放ap2空间
				{
					delete _ptr;
				}
				_ptr = ap._ptr;
				ap._ptr = NULL;
			}
			return *this;
	  }
};
void test()
{
	int *p = new int(10);
	Auto_ptr<int> ap1(p);
	Auto_ptr<int> ap2(ap1);
	ap2 = ap1;
}

这就是autoptr,尽管如此解决了初始化和赋值的问题，但是比如ap2=ap1,ap1这块空间就不能使用了，还是有严重缺陷的，但是为什么还要知道他呢，因为他还在我们的库里面，C++一旦产生的语法就不能取消，这就是向前兼容

上面的不好用怎么办呢？因为实在太烂了，所以有人就会造轮子，就出现了boost，他不是C++的标准库但是是比较重要的一个库
他产生了自己一套智指针

其实C++还有自己的几种智能指针

1.unique_ptr

2.shared_ptr

weak_ptr他其实是参考了boost

对上图中的代码做一些解释

scoped简单粗暴，防拷贝的设计

shared引用计数功能更全比较复杂，效率相对会比较低，还有循环引用的缺陷，用weak ptr去解决
1.首先来说名scoped ptr

template<class T>
class ScopdePtr
{
public:
	//raii
	ScopdePtr(T *ptr) :_ptr(ptr){}
	~ScopdePtr()
	{
		delete _ptr;
	}
	//智能指针的特性
	T& operator*()
	{
		return *_ptr;
	}
	T operator->()
	{
		return *_ptr;
	}
private://注意声明为私有的
	ScopdePtr(ScopdePtr<T>&);//放拷贝,只声明不定义，就无法调用拷贝哦
	ScopdePtr<T> operator=(ScopdePtr<T>&);
private:
		T *_ptr;
	//解决拷贝的问题，防拷贝
};
void testScopdePtr()
{
	ScopdePtr<int> sp1(new int(10));
	ScopdePtr<int> sp2(sp1);
}
int main()
{
	testScopdePtr();
	return 0;
}
2.scoped array

注意这个里面的operator*和operator->就没什么用了

template<class T>
class ScopdeArray
{
public:
	//raii
	ScopdeArray(T *ptr) :_ptr(ptr){}
	~ScopdeArray()
	{
		delete [] _ptr;
	}
	//智能指针的特性
	/*T& operator*()
	{
		return *_ptr;
	}
	T operator->()
	{
		return *_ptr;
	}*/
	 T &operator[](size_t pos)
	{
		return _ptr[pos];
	}
private://注意声明为私有的
	ScopdeArray(ScopdeArray<T>&);//放拷贝,只声明不定义，就无法调用拷贝哦
	ScopdeArray<T> operator=(ScopdeArray<T>&);
private:
	T *_ptr;
	//解决拷贝的问题，防拷贝
};
void testScopdeArray()
{
	ScopdeArray<int> sp1(new int(10));
	ScopdeArray<int> sp2(sp1);
}
int main()
{
	testScopdeArray();
	return 0;
}
3.shared ptr 

template<class T>
class SharedPtr
{
public:
	SharedPtr(T *ptr)
		:_ptr(ptr)
		, refCount(new int(1)){}
	~SharedPtr()
	{
		if (--(*refCount) == 0)
		{
			delete _ptr;
			delete refCount;
		}
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	SharedPtr(SharedPtr<T> &sp)
		:_ptr(sp._ptr)
		, refCount(sp.refCount)
	{
		++(*refCount);
	}
	SharedPtr& operator=(const SharedPtr<T> &sp)
	{
		if (_ptr != sp._ptr)
		{
			if (--(*refCount) == 0)
			{
				delete _ptr;
				delete refCount;
			}
			_ptr = sp._ptr;
			refCount = sp.refCount;
			++(*refCount);
		}
	}
private:
	T *_ptr;
	int *refCount;
};
void testSharedPtr()
{
	SharedPtr<int > sp1(new int(10));
	SharedPtr<int> sp2(sp1);
}
int main()
{
	testSharedPtr();
		return 0;
}
4.shared array 

template<class T>
class SharedArray
{
public:
	SharedArray(T *ptr)
		:_ptr(ptr)
		, refCount(new int(1)){}
	void release()
	{
		if (--(*refCount) == 0)
		{
			delete[] _ptr;
			delete refCount;
		}
	}
	~SharedArray()
	{
		release();
	}
	SharedArray(SharedArray<T> &sp)
		:_ptr(sp._ptr)
		, refCount(sp.refCount)
	{
		++(*refCount);
	}
	SharedArray& operator=(const SharedArray<T> &sp)
	{
		if (_ptr != sp._ptr)
		{
			release();
			_ptr = sp._ptr;
			refCount = sp.refCount;
			++(*refCount);
		}
		return *this;
	}
	T& operator[](size_t pos)
	{
		return _ptr[pos];
	}
private:
	T *_ptr;
	int *refCount;
};
5.shared中的循环引用

看如下代码：

template<class T>
class SharedPtr
{
public:
	SharedPtr(T *ptr=NULL)
		:_ptr(ptr)
		, refCount(new int(1)){}
	void release()
	{
		if (--(*refCount) == 0)
		{
			if (_ptr == NULL)
				return;
			printf("0x%p\n", _ptr);
			delete _ptr;
			delete refCount;
		}
	}
	~SharedPtr()
	{
		release();
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	SharedPtr(SharedPtr<T> &sp)
		:_ptr(sp._ptr)
		, refCount(sp.refCount)
	{
		++(*refCount);
	}
	SharedPtr<T>& operator=(const SharedPtr<T> &sp)
	{
		if (_ptr != sp._ptr)
		{
			release();
			_ptr = sp._ptr;
			refCount = sp.refCount;
			++(*refCount);
		}
		return *this;
	}
private:
	T *_ptr;
	int *refCount;
};
template<class T>
class weakptr
{
public:
	weakptr() :_ptr(NULL)
	{}
	weakptr(const SharedPtr<T>& sp) :_ptr(sp._ptr){}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T *_ptr;
};
struct ListNode
{
	SharedPtr<ListNode> _perv;
	SharedPtr<ListNode> _next;
};
void testcycle()
{
	SharedPtr<ListNode> cur = new ListNode;
	SharedPtr<ListNode> next = new ListNode;
	cur->_next = next;
	next->_perv = cur;
}
int main()
{
	testcycle();
	system("pause");
	return 0;
}
重点看这段代码： 

struct ListNode
{
	SharedPtr<ListNode> _perv;
	SharedPtr<ListNode> _next;
};
void testcycle()
{
	SharedPtr<ListNode> cur = new ListNode;
	SharedPtr<ListNode> next = new ListNode;
		cur->_next= next;
		next->_perv= cur;
}
int main()
{
	testcycle();
	system("pause");
	return 0;
}
这里就产生了循环引用

在这注意：


  内存并未释放

解决方法就是用weakptr

代码如下：

template<class T>
class weakptr
{
public:
	weakptr() :_ptr(NULL)
	{}
	weakptr(const SharedPtr<T>& sp) :_ptr(sp._ptr){}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T *_ptr;
};
其作用只是托管指针空间不进行操作

用法如下代码

template<class T>
class weakptr;
template<class T>
class SharedPtr
{
public:
	friend class weakptr<T>;
	SharedPtr(T *ptr=NULL)
		:_ptr(ptr)
		, refCount(new int(1)){}
	void release()
	{
		if (--(*refCount) == 0)
		{
			if (_ptr == NULL)
				return;
			printf("0x%p\n", _ptr);
			delete _ptr;
			delete refCount;
		}
	}
	~SharedPtr()
	{
		release();
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	SharedPtr(SharedPtr<T> &sp)
		:_ptr(sp._ptr)
		, refCount(sp.refCount)
	{
		++(*refCount);
	}
	SharedPtr<T>& operator=(const SharedPtr<T> &sp)
	{
		if (_ptr != sp._ptr)
		{
			release();
			_ptr = sp._ptr;
			refCount = sp.refCount;
			++(*refCount);
		}
		return *this;
	}
private:
	T *_ptr;
	int *refCount;
};
template<class T>
class weakptr
{
public:
	weakptr() :_ptr(NULL)
	{}
	weakptr(const SharedPtr<T>& sp) :_ptr(sp._ptr){}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T *_ptr;
};
struct ListNode
{
	weakptr<ListNode> _perv;
	weakptr<ListNode> _next;
};
void testcycle()
{
	SharedPtr<ListNode> cur = new ListNode;
	SharedPtr<ListNode> next = new ListNode;
	cur->_next = next;
	next->_perv = cur;
}
int main()
{
	testcycle();
	system("pause");
	return 0;
}


这样就释放了，解决了循环引用的问题。

IT_iverson
关注
专栏目录
智能指针与数组
sesiria的博客
06-06 8061
有的时候需要由local函数在heap中alloc 一个数组空间并返回给外部使用。例如在windows编程中常常需要转换编码， 转换编码返回值常常是alloc 在heap中如果例如返回一个char *. 如果外部在使用完以后不做删除操作就容易造成内存泄漏。 本质上char* 在heap中是一个char[] 。可以将返回值存在智能指针中，来自动销毁(shared_ptr, unique_ptr)
c++智能指针最全知识点即面试题目总结
最新发布
02-27
本篇文章收集了近一年来所有关于智能指针的面试相关内容。以智能指针的面试题线索，穿插讲解完最常用的四种智能指针的各个方面。本文讲解4个智能指针的基本概念和特性，以及其他设计到的知识点。讲解的过程中，如果...
C++智能指针梳理
chsmiao
10-31 4871
C++智能指针梳理
C++智能指针
南宫封清的博客
12-10 508
数组的智能指针的限制: 1，unique_ptr的数组智能指针，没有*和->操作，但支持下标操作[] 2，shared_ptr的数组智能指针，有*和->操作，但不支持下标操作[]，只能通过get()去访问数组的元素。 3，shared_ptr的数组智能指针，必须要自定义deleter 或者使用helpestd::shared_ptr<int>p(newint[10...
C++智能指针详解
asdasd121312dasd的博客
11-19 566
我们用new或者malloc申请一段空间之后，没有调用delete或者free，导致这部分申请的空间没有被释放，就像我们买了个房子，但是不记得房子的地址，我们也没办法入住使用这个空间，这个空间只能白白放着没法利用，这样就造成了资源浪费。如果使用移动构造的方式初始化智能指针对象，只是转让了内存的所有权，管理内存的对象不会增加，因此内存引用技术不会增加。std::unique_ptr是一个独占型的智能指针，它不允许其他的智能指针共享其内部的指针，可以通过它的构造函数初始化一个独占智能指针，
【智能指针一】智能指针初识
junxuezheng的博客
10-16 790
智能指针是存储指向动态分配（堆）对象指针的类，用于生存期的控制，能够确保在离开指针所在作用域时，自动地销毁动态分配的对象，防止内存泄露。智能指针的核心实现技术是引用计数，每使用它一次，内部引用计数加1，每析构一次内部的引用计数减1，减为0时，删除所指向的堆内存。（下面图片是错误的）解释：虽然无法赋值和拷贝，但是，如上面的demo，假如你用get和reset就是另外的情况了，因为程序并不知道你把地址赋值给了谁，但是析构会报错的。谣言1：它持有对对象的独有权，即两个 unique_ptr 不能指向一个对象。
C++智能指针-unique-ptr智能指针详解.pdf
02-27
《C++智能指针——unique_ptr智能指针详解》 智能指针是C++中用于自动管理动态分配内存的一种工具，它可以确保在适当的时候自动释放内存，从而避免内存泄漏的问题。其中，`unique_ptr`是一种特殊的智能指针，它拥有...
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
C++ 引用计数技术及智能指针的简单实现
12-22
智能指针是C++编程中用来自动管理动态内存的一种机制，它的主要目标是解决C++中手动内存管理带来的问题，如内存泄漏和悬垂指针。引用计数是智能指针实现中的关键技术之一，用于追踪对象被引用的次数，从而决定何时...
c++11&14-智能指针要点汇总
12-17
但像java等其他一些语言则不会有这样的问题，为什么呢，因为它们有很好的处理内存的方法，比如java的垃圾回收机制，现在，我们c++终于也有了智能指针。 1. 什么是智能指针 简单地说，智能指针是用对象去管理一个...
c++中的智能指针与类型转换
hqb_newfarmer的博客
02-18 1433
c++中的智能指针与类型转换
C++ 智能指针
char_pang_main_xue的博客
10-10 602
https://blog.csdn.net/u011616739/article/details/62052179 1 动态内存 1，C++程序中所使用的对象都是有着严格定义的生存期。 全局对象：在程序启动时分配，程序结束时销毁。 局部对象：在进去其定义所在的程序块时被创建，在离开块时销毁。 局部static对象：在第一次使用前分配，在程序结束时销毁。 局部变量： 作用域：{}...
C++ 智能指针 ：内存泄漏、 RAII、智能指针、auto_ptr、unique_ptr、shared_ptr、weak_ptr、定制删除器deleter
凌桓丶的博客
07-29 1228
文章目录RAII内存泄漏智能指针auto_ptrunique_ptrshared_ptrweak_ptr定制删除器 RAII 内存泄漏 智能指针 auto_ptr namespace lee { /* c++98 auto_ptr 实现思路:管理权转移 缺陷:当管理权转移后会导致被转移的指针悬空，访问就会报错，如果不熟悉它的特性就会出问题。 */ template<class T> class auto_ptr { public: auto_ptr(T* pt
C++对象运算符重载，容器迭代器
weixin_40533189的博客
02-02 1582
+，++， += 、其他的运算符重载函数差不多,以及输出out,输入 in #include <iostream> using namespace std; /* C++ 运算符重载:使对象的运算表现得和编译器内置类型一样 template<typename T> T sum(T a, T b) { return a+ b; //a.+(b) } 1.编译器做对象运算的时候，会调用对象的运算符重载函数（优先调用成员方法）；如果没有成员方法 就在全局作用域找.
c ++的operator的两种用法
热门推荐
和大黄的博客
06-03 1万+
operator，它有两种用法，一种是operator overloading（操作符重载），一种是operator casting（操作隐式转换）。 1.operator overloadingC++可通过operator 重载操作符，格式如下：类型T operator 操作符 ()，如比重载+，如下所示#includeusing namespace std;#include
operator[] 运算符返回引用和返回值得不同const修饰
shujianlove0的博客
12-03 541
对于返回值的，一般作为右值进行获取，所以这个过程中应该是不变动内部的值 对于返回引用的，一般作为左值进行赋值，所以不能采用const修饰 float operator[] (const size_t i) const{ return *(&amp;x+i); } float&amp; operator[] (const size_t i){ return *(&amp;x+i); } ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值