异常和智能指针

智能指针的认识

智能指针是一种C++语言中用于管理动态内存的工具，它们可以自动管理内存的分配和释放，从而避免内存泄漏和悬空指针等问题。智能指针可以跟踪指向的对象的引用次数，并在需要时自动释放被引用的内存，这极大地提高了内存管理的安全性和便利性。

C++标准库提供了三种类型的智能指针：

std::auto_ptr：管理权转移的思想，当进行赋值操作时会将原对象置空，而新对象指向该空间。
std::unique_ptr：独占型智能指针，表示它所指向的对象只能被一个指针拥有（即不能进行赋值），一旦该指针销毁，它所指向的对象也会被销毁。
std::shared_ptr：共享型智能指针，允许多个指针共同管理同一个对象，通过引用计数来跟踪对象的引用次数，当引用计数为0时自动释放对象内存。

其实智能指针的使用是在异常时引出的，所以我们先了解一下异常：

异常

首先我们其实在堆区new空间的时候就见过异常，当我们想要开辟的空间太大而无法申请到就会抛异常：

概念

异常是我们处理错误的一种方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的直接或间接的调用者处理这个错误。

throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。
catch: 在您想要处理问题的地方，通过异常处理程序捕获异常 catch 关键字用于捕获异常，可以有多个catch进行捕获。
try:try 块中放置可能抛出异常的代码,它后面通常跟着一个或多个 catch 块。

使用

double Division(int a, int b)//除法计算
{
	// 当b == 0时抛出异常
	if (b == 0)
		throw "不能除0";
	else
		return ((double)a / (double)b);
}
void Func()
{
	int len, time;
	cin >> len >> time;
	cout << Division(len, time) << endl;
}
int main()
{
	try 
	{
		Func();
	}
	catch (const char* errmsg)//抛出什么类型就捕获什么类型的数据
	{
		cout << errmsg << endl;
	}
	catch (...)//捕获抛出的未知异常
	{
		cout << "unkown exception" << endl;
	}
	return 0;
}

我们要知道当我们在throw抛出异常的时候，此时就会立马调用最近的catch进行，捕获异常，如果没有调用到catch的话，或者catch的类型不匹配的话就会出现：

而且我们抛异常之后会被立马捕获异常，而这之间的代码并不会执行，直接就开始执行catch后续代码。但是也别忘了在此我们调用函数的过程中是创建了栈帧的，所以我们catch捕获异常后会销毁之前的栈帧空间。

实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获。这里就引入C++标准库异常体系了：

C++标准库异常体系

这个exception类就是所有标准C++异常的父类，所以当我们C++程序内部抛异常时都可以用父类对象接受捕获异常。

int main()
{
	try 
	{
		new int[7000000000];
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "Unkown Exception" << endl;
	}
	return 0;
}

异常规范

//C++11
thread() noexcept;//表示函数体内一定不会抛异常，如果抛了就运行出错
thread (thread&& x) noexcept;

//C++98
void fun() throw();//表示函数体内一定不会抛异常，如果抛了也会捕获

// 这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() throw(A，B，C，D);
// 这里表示这个函数只会抛出bad_alloc的异常
void fun() throw (std::bad_alloc);

我们是否注意到异常的一点缺陷，当抛异常后就会立马执行到捕获异常的位置，这中途的栈帧都将销毁，而代码也不会执行，但是如果这之中需要我们释放堆区空间的话，那么就会造成内存泄漏。所以我们就有了智能指针的引出：

智能指针使用与实现

我们知道catch接受异常时可能会导致从堆区动态开辟的空间未释放从而造成内存泄漏，所以我们就采用了智能指针去构造的对象，然后在栈帧销毁的时候就会自动调用析构函数了，而不需要我们进行手动调用。

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");

	return a / b;
}
void Func()
{
	int* p1 = new int;
	int* p2 = new int;
	cout << div() << endl;//调用div()函数
	delete p1;
	delete p2;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

这里我们发现会调用div函数，然后如果抛异常的话就会造成delete函数未执行，从而导致内存泄漏的情况，因此我们就通过智能指针的方式进行改造（以shared_ptr为例）：

template<class T>
class Smart_ptr
{
public:
	Smart_ptr(T* ptr = nullptr)
		:_ptr(ptr)
	{}
	~Smart_ptr()
	{
		delete _ptr;
		cout << "delete[] " << _ptr << endl;
	}
private:
	T* _ptr;
};

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");

	return a / b;
}
void Func()
{
	Smart_ptr<int> p1 = new int;
	Smart_ptr<int> p2 = new int;

	cout << div() << endl;  
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

通过以上的方式，我们将需要创建的对象去构造智能指针，此时当战争销毁的时候就会自动调用类的析构函数，从而释放空间。而这种方式的原理就是就是RAII：

RAII

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

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

shared_ptr

template<class T>
class Smart_ptr
{
public:
	
	Smart_ptr(T* ptr = nullptr)
		:_ptr(ptr)
		,_count(new int(1))
	{}

	Smart_ptr(const Smart_ptr<T>& tmp)//拷贝构造（浅拷贝）
		:_ptr(tmp._ptr)
		,_count(tmp._count)
	{
		(*_count)++;//引用计数++
	}

	Smart_ptr<T>& operator=(const Smart_ptr<T>& tmp)
	{
		if(_ptr!=tmp._ptr)//防止自己给自己赋值()
		{
			//this->~Smart_ptr();//没问题但是不好

			if (--(*_count) == 0)//该空间可能不仅被一个对象所指，所以当前的记数-1
			{
				delete[] _ptr;
				delete _count;
				//cout << "delete[] " << _ptr << endl;
			}

			_ptr = tmp._ptr;
			_count = tmp._count;
			(*_count)++;

			return *this;
		}
	}


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

	~Smart_ptr()
	{
		if (*_count > 1)
			(*_count)--;
		else
		{
			delete _ptr;
			delete _count;
			//cout << "delete[] " << _ptr << endl;
		}
	}
private:
	T* _ptr;
	int* _count;//引用计数(关键就是指针存放)
	//光整型存放会有问题，会导致拷贝构造后的数据不是同一个记数
};

虽然说shared_ptr可以解决这种问题，但是shared_ptr最大的缺陷就是循环引用，而对于循环引用问题的解决就引出了weak_ptr。先看一下什么是循环引用：

循环引用

循环引用是指在编程中，两个或多个对象相互引用，形成一个循环的引用链，导致它们无法被正常地回收或释放。

struct ListNode
{
	int val;
	Smart_ptr<ListNode> next;
	Smart_ptr<ListNode> pre;

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

void test()
{
	Smart_ptr<ListNode> n1(new ListNode);
	Smart_ptr<ListNode> n2(new ListNode);
	n1->next = n2;
	n2->pre = n1;
}
int main()
{
	test();

	return 0;
}

在该种情形时可以分析出：n1->next=n2;这段代码使得n2指针指向的空间计数为2,而n2->pre=n1；使得n1指向的空间记数也为2，而且当该栈帧空间销毁时会先析构n2这块空间，再析构n1这块空间：

    ~Smart_ptr()
	{
		if (*_count > 1)
			(*_count)--;
		else
		{
			delete _ptr;
			delete _count;
			//cout << "delete[] " << _ptr << endl;
		}
	}

当析构n2空间时会先引用计数--，然后发现n2该对象成员函数是两个内置类型，不做处理，所以就开始析构n1对象，同样是引用计数--，此时就程序结束了。

但是_next还指向下一个节点。而且_prev还指向上一个节点。从而导致堆区内存空间未释放所以造成了内存泄漏。所以想要正确释放空间就要析构n1的_next节点（释放n2）和n2的_pre节点（释放n1），但是_next是n1的成员，_pre又是n2的成员，所以想要析构_next和_pre的话就又要析构n1和n2，从而形成了闭环。

而以上情形就是循环引用。最终谁都不会释放，从而造成内存泄漏。

std::weak_ptr是一种用于解决shared_ptr相互引用时产生死锁问题的智能指针。也就是当多个对象指向同一空间时不会增加引用计数

// 简化版的weak_ptr
template<class T>
class weak_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;
};

此时的_next和_pre 的指针类型就可以是weak_ptr的类型：

定制删除器

当我们使用智能指针的时候其实都疏忽了一点，空间释放delete对象时的方式，当我们new的是单一的空间的时候就直接delete就行了，而当我们new的是一段连续的空间的时候就需要delete[]来释放空间，此时就很容易的联想到仿函数。我们库里的是采用重载构造函数模版的方式来解决问题：

所以我们就可以按照库的解决方式进行改造我们所写的代码：

namespace cr
{
    template<class T>
	class shared_ptr
	{
	public:

		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _count(new int(1))
		{}

		template<class D>//模版类型
		shared_ptr(T* ptr, D del)//重载构造函数
			: _ptr(ptr)
			, _count(new int(1))
			, _del(del)//设置为类成员用于析构调用
		{}

		shared_ptr(const shared_ptr<T>& tmp)//拷贝构造（浅拷贝）
			:_ptr(tmp._ptr)
			, _count(tmp._count)
		{
			(*_count)++;
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& tmp)
		{
			if (_ptr != tmp._ptr)//防止自己给自己赋值
			{
				if (--(*_count) == 0)
				{
					del(_ptr);//相当于调用operator()
					delete _count;
				}

				_ptr = tmp._ptr;
				_count = tmp._count;
				(*_count)++;

				return *this;
			}
		}

		~shared_ptr()
		{
			if (*_count > 1)
				(*_count)--;
			else
			{
				_del(_ptr);//相当于调用operator()
				delete _count;
			}
		}
	private:
		T* _ptr;
		int* _count;
		function<void(T*)> _del = [](T* ptr)->void {delete ptr; };//默认给缺省值
		//因为不知道_del的类型，采用function包装器包装，可以接受函数指针、lambda表达式、仿函数
	};
}

主函数中进行测试调用：

template<class T>
struct del//仿函数
{
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
}; 
struct ListNode
{
	int val;
	cr::shared_ptr<ListNode> next;
	cr::shared_ptr<ListNode> pre;

	~ListNode()
	{
		cout << "~ListNode" << endl;
	}
};
int main()
{
	cr::shared_ptr<ListNode> p1(new ListNode[10],del<ListNode>());
	cr::shared_ptr<ListNode> p2(new ListNode[10],[](ListNode* ptr)->void{delete[]ptr; });
	cr::shared_ptr<ListNode> p3(new ListNode);
    
    return 0;
}