智能指针

一. 为什么需要智能指针

下面我们先分析以下下面这段程序有没有什么内存方面的问题？

int div(){
	int a,b;
	cin >> a >> b;
	if(b==0)
		throw invalid_argument("除0错误");
	return a/b;
}
void f1(
{
	int* p=new int;
	cout << div() << endl;
	delete p;
}

int main(){
	try{
		f1();
	}
	catch(exception& e){
		cout << e.what() <<endl;
	}
}

在f1中会有内存泄漏问题，当div函数中出现异常，会直接停止f1的执行，去执行main中的异常处理。
所以会导致p指针的资源无法被释放，造成内存泄漏

解决方法：
1.

将cout << div() << endl;改为：
try{
	cout << div() << endl;
}
catch(...){
	delete p;
}
delete p;

2 .用智能指针去进行处理，我们自己构造一个简单的

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

同时在void f1()中：

void f1(){
	int* p = new int;
	SmartPtr<int> sp(p);
	cout << div() << endl;
}

将指针交给SmartPtr对象进行管理，这个对象在构造时将该指针保存起来。
出了作用域时，该对象调用析构函数去处理指针（无论正常结束还是抛异常，它都会跳出该作用域）

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

1. RAII

RAII（Resource Acquisition Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术

在对象构造时获取资源，接着控制对资源的访问在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源、借此，我们实际上吧管理一份资源的责任托管给了一个对象。这样做有两大好处：

• 不需要显示地释放资源
• 采用这种方式，对象所需的资源在其生命周期内始终保持有效

应用：

1. 智能指针
2. 锁守卫(lock_guard)(unique_lock)

2. 像指针一样使用

如之前我们写SmartPtr。

template <class T>
class SmartPtr{
public:
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}
	
	//去重载operator*
	T& operator*{
		return *_ptr;
	}

	//去重载operator->
	T* operator->(){
		return _ptr;
	}

	~SmartPtr(){
		delete ptr;
	}
private:
	T* _ptr;
};

三. C++库中也有智能指针

1. auto_ptr

在C++98中，在< memory >库中

当我们要用智能指针去拷贝构造时

• 我们浅拷贝，两个指针指向同一块地址空间，将再析构时delete两次
• 我们又不能用深拷贝，因为指针拷贝时，p1和p2本身就指向同一块空间，为浅拷贝

那我们设计auto_ptr是如何解决呢？

转移控制权
保证一次只有一个对象再管理资源
如：（只是我们为了方便理解写的，我们自己实现也可这样写）

auto_ptr(auto_ptr<T>& ap)
	:_ptr(ap._ptr)
{
	ap._ptr=nullptr;
}

这个时候再~auto_ptr()时，要去delete它，要先判断是否为空。

这样又引入一个问题

auto_ptr<int> sp1(new int)
auto_ptr<int> sp2(sp1);
*sp2=10;
*sp1=20;

会出问题，对空指针进程操作

所以很多公司都明确的规定，不能使用auto_ptr

新的智能指针

在C++11标准中，又增添了新的智能指针。

unique_ptr

简单粗暴的解决拷贝问题：禁止拷贝
自己模拟实现可这样:

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

shared_ptr

该智能指针运用了引用计数来解决拷贝问题

由上图可知，释放sp2时，计数–。当计数减为0时，delete该指针

那如果我们要实现该怎么实现？
直接增加一个int _count去计数，不可以，因为这样设计不同对象有不同的_count
将该变量定义为静态成员变量，不可以，因为静态是属于整个类对象共享的，如果sp1和sp2共同管理一个空间（指针），sp3和sp4管理同一个块空间（指针），但只有一个共同变量计数，会出问题

所以我们可以设计一个计数指针，int* _pcount；这样拷贝后管理同一块空间的对象，因为指针浅拷贝，都会指向同一块空间的_pcount

class shared_ptr{
	shared_ptr(T* ptr)
		:_ptr(ptr)
		,_pcount(new int(1))
	{}
	shared_ptr(const shared_ptr<T>& sp)
		:_ptr(sp._ptr)
		,_pcount(sp._pcount)
	{
		++(*_pcount);
	}
	shared_ptr<T>& operator=(const shared_ptr<T>& sp){
		if(_ptr != sp._ptr){
			_pcount = sp._pcount;
			_ptr = sp._ptr;
			(*sp._pcount)++;
		}
		return *this;
	}
	~shared_ptr(){
		if(--(*_pcount)==0){
			delete _ptr;
			delete _pcount;
		}
	}
};

拷贝构造和赋值构造、析构有很多代码类似，可以封装AddRef()，ReleaseRef()两个私有函数

除此之外，还可以在多线程使用其时，进行加锁处理，保证其是原子的

weak_ptr

不参与资源的管理，主要解决shared_ptr循环引用的问题

总：智能指针的实现要考虑三个方面的问题

• RAII
• 像指针一样使用operator*和operator->
• 智能指针对象拷贝问题

三. 问题

shared_ptr循环引用问题

struct ListNode{
	bit::shared_ptr<ListNode> _next;
	bit::shared_ptr<ListNode> _next;
	int _val;
}

void test_shared_ptr_cycle_ref(){
	bit::shared_ptr<ListNode> node1(new ListNode);
	bit::shared_ptr<ListNode> node2(new ListNode);
	node1->_next=node2;
	node2->_prev=node1;
}

这个时候node1与node2中的prev一起管理一块空间a
node2与node1中的next管理一块空间b。

当我们去释放node1和node2时。
node1中的_next要释放，得空间b要释放。
而空间b中存放着_prev，_prev指向空间a，_prev要释放，得先把空间a释放。
而空间a又存放着node1的_next。这样陷入死循环

解决方法：
将ListNode结构中的类型换为weak_ptr

weak_ptr可传入shared_ptr去构造，但不增加其引用计数。因为weak_ptr只是使用去指针，不管理资源

1. weak_ptr自己的简单实现

template<class T>
class weak_ptr{
private:
	T* _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;
	}
}