智能指针

最新推荐文章于 2022-02-02 18:06:07 发布
最新推荐文章于 2022-02-02 18:06:07 发布
阅读量629 收藏
点赞数 1
分类专栏： C++ 文章标签： 智能指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/it_iverson/article/details/78091366
版权

一.为什么会有智能指针

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

首先看下面的代码：

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
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C++】三种智能指针（auto_ptr，unique_ptr，shared_ptr）
Miss_Monster的博客
04-13 2022
c++中的智能指针主要是基于RAII思想的。 不懂RAII思想的同学可以看看这篇博文-->RAII思想---利用对象生命周期来控制程序资源 智能指针的两大要素 RAII思想：把资源交给这个对象管理 像指针一样的行为（重载operator*和operator->） template<class T> class SmartPtr { public://交给对...
C++ 智能指针
04-20
C++ 智能指针 C++ 智能指针是一种特殊的指针，它可以自动管理动态分配的内存，避免了手动释放内存带来的问题。智能指针的实现是通过模板类 auto_ptr 来实现的。 auto_ptr 类模板的构造函数 ----------------------...
C++智能指针
05-24
C++ 中推出了强大的智能指针smart_ptr ，本文具体说说 shared_ptr 和 weak_ptr ，特别是 enable_shared_from_this 和 shared_from_this
C++11之智能指针
12-22
使用c++，除了c++的语法外，指针是我们面临的的大一个问题，由于使用不当会导致程序意外退出，或着内存的占用越来越多，总结起来这些错误由以下三个原因造成。 　　1 野指针：指针指向的内存已经被释放，但是我们还在使用该指针，或者还在使用之前指向的指针，此时程序会崩溃，也有可能导致已经释放的内存被重新分配给程序使用，造成意想不到的后果。 　　2 重复释放：程序尝试释放已经被释放的内存单元，或者释放已经被重新分配过的内存单元，会导致重复释放错误。 　　3 内存泄漏：不需要的内存单元没有释放，一旦程序一直在重复这样的操作，会导致程序的内存占用月来越高。 　　虽然显示的手动管理内存，给程序的内存
C++智能指针用法详解
12-22
一、简介 　　由于 C++ 语言没有自动内存回收机制，程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete，流程太复杂，终导致没有 delete，异常导致程序过早退出，没有执行 delete 的情况并不罕见。 　　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: intrusive_ptr。你可能会想，如此多的智能指
在指定的内存块中创建对象
hjh2005的专栏
08-02 749
代码举例如下： #include char *buf= new char [1024*1024]; double *array=new(buf) double[10]; 如果创建的是类对象则要显示地调用类的析构函数。 参考： http://hubeihuyanwei.blog.163.com/blog/static/28205284201171722359640
IO操作
mxlxiao7的专栏
09-13 1264
第一节：概述 1. io用来处理设备之间的数据传输。 2. java对数据的操作时通过流的方式 3. 流按照操作数据分为两种：字节流与字符流。 4. 流按流向分为：输入流和输出流。 5. 字节流的抽象基类: inputStream |--AudioInputStream |--ByteArrayInputStream |--FileInputStream |--FilterInp
用三段 140 字符以内的代码生成一张 1024×1024 的图片<转载>
weixin_34080903的博客
08-19 180
原文出处：http://www.matrix67.com/blog/archives/6039#more-6039 http://codegolf.stackexchange.com/questions/35569/tweetable-mathematical-art Kyle McCormick 在 StackExchange 上发起了一个叫做 Tweetable Mathematical...
C++对象运算符重载，容器迭代器
weixin_40533189的博客
02-02 1516
+，++， += 、其他的运算符重载函数差不多,以及输出out,输入 in #include <iostream> using namespace std; /* C++ 运算符重载:使对象的运算表现得和编译器内置类型一样 template<typename T> T sum(T a, T b) { return a+ b; //a.+(b) } 1.编译器做对象运算的时候，会调用对象的运算符重载函数（优先调用成员方法）；如果没有成员方法 就在全局作用域找.
C++基础16:智能指针的用法
weixin_42278523的博客
07-13 304
1. 智能指针的简单应用 功能：处理没有释放内存，所引起的内存泄漏的问题； （1）智能指针的初始化类似于容器； auto_ptr<int> ptr(new int(10)); //(1)智能指针的初始化类似于容器；
C++在设计和使用智能指针
12-22
　而此时智能指针可能能够帮助我去解决问题。 　智能指针（smart pointer）是利用个引用计数的策略去处理指针的释放，从而保证指针的安全性。 　通常情况下，我们会自己去设计一个智能指针类去管理自己的指针对象...
黑马程序员——Java基础---IO流（字符流、字节流、转换流、流操作规律）
中仔的博客
11-24 2758
简述： IO(Input Output) IO流用于处理设备之间的数据传输。(比如硬盘上的文件，内存中驻留的数据)IO流是用于操作数据的，数据的最常见体现形式是：文件。 Java对数据的数据的操作是通过流的方式。Java用于操作流的对象都在IO包中。流按操作数据分为两种：字节流和字符流。流按流向分为：输入流和输出流。 注意：流的操
IO(五、FileReader第二种读数据)char[] buf=new char[1024];
ygl6150373的博客
10-12 782
import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; //通过字符数组读取 public class FileReader2 { public static void main(String[] args) { FileReader fr=null
Java基础——IO流
Yuhang_Z的博客
02-01 275
IO流概述 什么是流？ 流是有起点和终点的有序字节序列的集合。 流的分类 输入流/输出流：流根据方向可以分为输入流与输出流，输入与输出是相对于内存而言的，从内存村来就是输出，到内存中就是输入。 字节流/字符流：流根据读取数据的方式可以分为字节流与字符流，字节流是按照字节的方式读取，字符流是按照字符的方式读取，一次读取2个字节（Java中1个字符占2个字节）。 节点流/处理流：如果直接从...
JVM 内存分配与回收学习（1）
BiggerLee的博客
09-28 274
随笔。记录各类型在堆内存中占用内存空间大小的理解： 引用类型在堆中占用4字节， byte，boolean基本类型在堆中占用1字节， char，short基本类型在堆中占用2字节， int，float基本类型在堆中占用4字节， long，double基本类型在堆中占用8字节。   用代码验证下，以下代码的vm参数为 -Xmx20m -Xms20m  -XX:+HeapDumpOnOu...
黑马程序员——IO流
u010584273的专栏
07-22 395
这个章节是我目前为止学的最最吃力的了，
菱形继承和虚函数
IT_iverson的博客
10-11 1787
此篇博客主要介绍菱形虚拟继承和虚函数的混合情况下的模型分析。 一首先介绍一下虚函数的实质内容 代码如下 class A { public: int a; virtual void fun1() { cout << "A::fun1 "<< endl; } }; class B :public A { public: int b; virtual void fun1()//函数
智能指针 reset
最新发布
08-31
智能指针的 `reset` 函数是用于重置智能指针所管理的对象。当调用 `reset` 函数时，智能指针会释放当前管理的对象，并接管新的对象的所有权。具体来说，它会将智能指针内部的指针设置为新对象的地址，并且会释放旧...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值