【C++】智能指针

news2024/11/24 16:19:22

一、资源的管理

RAII:Resource Acquisition Is Initialization的简称，其翻译过来就是“资源获取即初始化”，即在构造函数中申请分配资源，在析构函数中释放资源，它是C++语言中的一种管理资源、避免泄漏的良好方法。

C++语言的机制保证了，当创建一个类对象时，会自动调用构造函数，当对象超出作用域时会自动调用析构函数。RAII正是利用这种机制，利用类来管理资源，将资源与类对象的生命周期绑定。

利用对象生命周期来控制程序资源的简单技术
（对象生命周期--------------程序资源）

在对象构造时获取资源，
接着控制对资源的访问使之在对象的生命周期内始终保持有效，
最后在对象析构的时候释放资源

—>把管理一份资源的责任托管给了一个对象

二、动态内存的管理

new：在动态内存中为对象分配空间并返回一个指向该对象的指针，我们可以选择对对象进行初始化
delete：接受一个动态对象的指针，销毁该对象，并释放与之关联的内存

问题：有时使用完对象后，忘记释放内存，造成内存泄漏的问题。

所谓的智能指针本质就是一个类模板，它可以创建任意的类型的指针对象，当智能指针对象使用完后，对象就会自动调用析构函数去释放该指针所指向的空间。

下面是智能指针的基本框架，所有的智能指针类模板中都需要包含一个指针对象，构造函数和析构函数。

template <class T>
class smartptr
{
	public:
		smartptr(T* _ptr)//构造函数
			:ptr(_ptr)
			{}
		~smartptr()//析构函数
		{
			if(ptr != nullptr)
			{
				cout<<"smartptr:delete"<<endl;
				delete ptr;
				ptr = nullptr;
			}
		}
	private:
		T* ptr;//指针对象
};

代码解读

smartptr(T* _ptr) :ptr(_ptr) {}

使用初始化列表来初始化字段
smartptr(T* _ptr){
	ptr = _ptr;
}

三、智能指针的定义和使用

智能指针不是一个指针，它其实是一个对象。它是通过C++的RAII机制实现的。主要是利用C++中对象在释放的时候，会自动调用析构函数这一特性。

所以，当智能指针对象释放的时候，在智能指针对象的析构函数中来释放其管理的内存资源。这样，开发人员就不需要手动去释放已经分配的内存空间。

3.1 shared_ptr原理介绍

shared_ptr是智能指针的一种，不仅通过RAII机制来管理内存资源，还引入了引用计数来解决当多个智能指针指向同一块内存空间的时候，何时释放这块内存空间的问题。

也就是说，同一时刻可以有多个shared_ptr拥有一块内存空间的所有权，当最后一个shared_ptr被销毁时，这块内存空间的引用计数为0时，这块内存空间将被释放。

shared_ptr对象有两个指针,一个是指向管理的内存空间，一个是指向内存控制块，内存控制块中包含引用计数和其他的一些信息（删除器和分配器）。

shared_ptr<Object> t1(new Object());
shared_ptr<Object> t2 = t1;

用图表示如下：
在这里插入图片描述
t1释放的时候，引用计数减一，然后释放t1的内存空间，如下：

当t2释放的时候，引用计数会再减一，这时引用计数就会变成0，这时就会释放Object的内存空间和内存控制块的空间，同时t2对象的空间也会被释放。

3.2 实现代码

#include <iostream>
using namespace std;

template <class T>
class shared_ptr
{
public:
	shared_ptr(T* _ptr)
		:ptr(_ptr)
	{
		ptrcount = new int(1);
		mt = new mutex;
	}

	void AddCount()
	{
		mt->lock();
		(*prtcount)++;
		mt->unlock();
	}

	shared_ptr(shared_ptr<T>& sp)
		:ptr(sp.ptr)
		,ptrcount(sp.ptrcount)
		,mt(sp.mt)
	{
		AddCount();
	}

	shared_ptr<T>& operator=(const shared_ptr<T>& sp)
	{
		if (sp.ptr != ptr)
		{
			Realse();
			ptr = sp.ptr;
			ptrcount = sp.ptrcount;
			mt = sp.mt;
			AddCount();
		}
		return *this;
	}

	~shared_ptr()
	{
		Realse();
	}

	int& use_count()
	{
		return *ptrcount;
	}

	void Realse()
	{
		bool deleteflag = false;
		mt->lock();
		if (--(*ptrcount) == 0)
		{
			delete ptrcount;
			delete ptr;
			ptrcount = nullptr;
			ptr = nullptr;
			deleteflag = nullptr;
		}
		mt->unlock();

		if (deleteflag == true)
		{
			delete mt;
			mt = nullptr;
		}
	}

	T& operator*()
	{
		return *ptr;
	}

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

private:
	T* ptr;
	int* ptrcount;
	mutex* mt;
};

3.3 shared_ptr使用方法

1）初始化

//通过构造函数初始化
shared_ptr<Test> t(new Test());
 
//使用make_shared来初始化智能指针
shared_ptr<Test> t = make_shared<Test>();

2）支持拷贝构造、赋值

shared_ptr<Test> t(new Test());
shared_ptr<Test> t1(t);
t1 = t;

获取原始指针

shared_ptr<Test> t = make_shared<Test>();
Test* pTest = t.get();

例子：

#include <iostream>
#include  <memory> // 需要包含这个头文件
using namespace std;

int main()
{
	// 使用 make_shared 创建空对象
	shared_ptr<int> p1 = make_shared<int>();
	*p1 = 78;
	cout << "p1 = " << *p1 << endl; // 输出78
	cout << p1 << endl;

	// 打印引用个数：1
	cout << "p1 Reference count = " << p1.use_count() << endl;

	// 第2个第3个 shared_ptr 对象指向同一个指针
	shared_ptr<int> p2(p1);
	shared_ptr<int> p3(p1);

	// 每个指针的引用计数
	cout << "p1 Reference count = " << p1.use_count() << endl;
	cout << "p2 Reference count = " << p2.use_count() << endl;
	cout << "p3 Reference count = " << p3.use_count() << endl;

	p1 = nullptr;
	cout << "p2 Reference count = " << p2.use_count() << endl;
	cout << "p3 Reference count = " << p3.use_count() << endl;
	return 0;
}