【C++11】智能指针

最新推荐文章于 2024-05-03 17:22:42 发布
最新推荐文章于 2024-05-03 17:22:42 发布
阅读量212 收藏 1
点赞数
分类专栏： C++学习 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67401157/article/details/132262651
版权

文章目录

一.为什么要有智能指针

在传统的C++中，我们通常使用new和delete来手动分配和释放内存。但是，手动管理内存非常容易出错，容易导致内存泄漏或者悬空指针的问题。智能指针的出现就解决了这个问题。

除了常规的忘记释放内存外，在C++引入了异常后，内存泄露的问题愈发严重，大家可以看看下面这段代码，当我输出第二个参数为0，产生整数除以0的异常后，会发生什么问题：

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	// 1、如果p1这里new 抛异常会如何？
	// 2、如果p2这里new 抛异常会如何？
	// 3、如果div调用这里又会抛异常会如何？
	int* p1 = new int;
	int* p2 = new int;
	cout << div() << endl;
	delete p1;
	delete p2;
    cout << "p1、p2释放" << endl;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

在这里插入图片描述

乍一看好像没什么问题，异常被捕获了，并且输出了我们想要的错误信息。

但是p1、p2指向的空间因为异常的跳转，其指向的空间没有得到释放，引发了经典的内存泄漏问题。

二.内存泄漏

1. 什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：

长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

内存泄漏是指针丢了还是内存丢了？

内存泄漏是指在程序运行过程中，动态分配的内存没有被正确释放，导致无法再被使用或者回收。一般情况下，内存泄漏是指程序中的指针丢失了对应的内存地址，从而导致无法释放这块内存。

2. 内存泄漏分类

C/C++程序中一般我们关心两种方面的内存泄漏：

堆内存泄漏(Heap leak)

堆内存指的是程序执行中依据需要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

3. 检测内存泄漏

检测工具内部原理：

申请内存用一个容器记录下来，释放内存时，从容器中删除掉。程序结束时，或者没有任务时，容器中的资源可能就是内存泄漏的。

4.如何避免内存泄漏

  1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
  2. 采用RAII思想或者智能指针来管理资源。
  3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
  4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

总结一下:

内存泄漏非常常见，解决方案分为两种：

  1. 事前预防型。如智能指针等。
  2. 事后查错型。如泄漏检测工具。

三.智能指针的原理与使用

1. RAII

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

即在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。

这种做法有两大好处：

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

例如现在，我们使用RAII思想设计释放资源的类：SmartPtr，来解决刚刚的异常跳转问题。

template<class T>
class SmartPtr
{
public:
        SmartPtr(T* ptr)
                :_ptr(ptr)
        {}
        ~SmartPtr()
        {
                cout << "delete:" << _ptr << endl;
                delete _ptr;
        }
private:
        T* _ptr;
};
int div()
{
        int a, b;
        cin >> a >> b;
        if (b == 0)
                throw invalid_argument("除0错误");
        return a / b;
}
void Func()
{
        SmartPtr<int> sp1(new int);
        SmartPtr<int> sp2(new int);
        cout << div() << endl;
}
int main()
{
        try {
                Func();
        }
        catch (const exception& e)
        {
                cout << e.what() << endl;
        }
        return 0;
}

正常输入的结果：

在这里插入图片描述

出现 了异常，出了作用域可以正常调用析构函数来释放空间

在这里插入图片描述

这便是RAII的设计思路，也是智能指针核心设计思想之一，即使用对象管理指针，出作用域自动调用析构函数来释放空间。

但上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：SmartPtr模板类中还得需要将* 、->重载下，才可让其

像指针一样去使用。

//1、使用RAII思想设计delete资源的类
//2、像指针一样的行为
template<class T>
class SmartPtr
{
public:
        SmartPtr(T* ptr)
                :_ptr(ptr)
        {}
        ~SmartPtr()
        {
                cout << "delete:" << _ptr << endl;
                delete _ptr;
        }
        //运算符重载两个操作符 --  模拟指针的操作
        T& operator* ()
        {
                return *_ptr; //返回_ptr的指向
        }
        T* operator->()   //有两个->，其中一个被省略了。
        {
                return _ptr; //返回指针
        }
private:
        T* _ptr;
};

总结一下智能指针的原理：

  1. RAII特性
  2. 重载operator*和opertaor->，具有像指针一样的行为。

上面我们基本实现了smartPtr，但是smartPtr的一大痛点就是拷贝，现在使用smartPtr默认的拷贝构造函来看看smart能不能进行拷贝：

在这里插入图片描述

直接就出现了报错，原因如下：

因为我们没有编写构造函数，所以编译器使用默认构造函数，这就导致其中的_ptr指向了同一空间，在出作用域时，会调用析构函数，这就导致对同一空间的二次释放，导致了报错。
在这里插入图片描述

现在我们就再来解决智能指针拷贝构造的问题：

来看看C++98版本的库中的auto_ptr

2. auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针。

关于auto_ptr的文档解释：std::auto_ptr文档

auto_ptr的实现原理：

  • 管理权转移的思想。

接下来我们使用库中的auto_ptr来实现拷贝，来观察库中的auto_ptr的拷贝构造做了什么事：

在这里插入图片描述
在这里插入图片描述

我们发现：

  • auto_ptr的拷贝构造是将原来的aptr1置为空，然后单独使用aptr2对象来指向该区域。他进行的是资源权转移，是不负责任的拷贝，会导致被拷贝对象悬空。

这里给出auto_ptr拷贝构造函数的实现：

//auto_ptr拷贝的实现--简单的赋值
auto_ptr(auto_ptr<T>& ap)
        :_ptr(ap._ptr)
{
    ap._ptr=nullptr
}

而auto_ptr的赋值运算符重载同样也是资源转移，例如以下代码：

在这里插入图片描述

而auto_ptr的赋值运算符重载的实现是怎样的呢？

auto_ptr的赋值，会先将被赋值对象指向的内容进行释放，然后进行赋值操作，再将赋值对象的指向置为空，实现如下：

auto_ptr<T>& operator=(auto_ptr<T>& ap)
{
        // 检测是否为自己给自己赋值
        if (this != &ap)
        {
                // 释放当前对象中资源
                if (_ptr)
                        delete _ptr;
                // 转移ap中资源到当前对象中
                _ptr = ap._ptr;
                ap._ptr = NULL;
        }
        return *this;
}

auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr，接下来我们看看常用的三种智能指针。

四.常用的智能指针

在C++98中推出auto_ptr，一直饱受诟病，在C++11中推出了三种功能较完善的智能指针，这也是实际中使用比较频繁的三种智能指针。

1. unique_ptr

C++11版本的库开始提供更靠谱的unique_ptr。

unique_ptr的实现原理：

  • 简单粗暴的防拷贝。

使用场景：

  • 只适用于不需要拷贝的一些场景，功能比较局限。

以下是C++11中对unique_ptr对于拷贝构造函数与赋值重载函数的处理：

在这里插入图片描述

那C++98没有delete，scoped_ptr(unique_ptr的前身)是如何实现的呢?

C++98中对于scoped_ptrde 拷贝构造函数和赋值重载函数的处理：声明但不实现+私有化

在这里插入图片描述

简易版的unique_ptr的实现步骤如下：

  1. 在构造函数中获取资源，在析构函数中释放资源，利用对象的生命周期来控制资源。
  2. 对*和->运算符进行重载，使unique_ptr对象具有指针一样的行为。
  3. 用C++98的方式将拷贝构造函数和拷贝赋值函数声明为私有，或者用C++11的方式在这两个函数后面加上=delete，防止外部调用。

代码如下：

namespace dianxia
{
	template<class T>
	class unique_ptr
	{
	public:
		//RAII
		unique_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{}
		~unique_ptr()
		{
			if (_ptr != nullptr)
			{
				cout << "delete: " << _ptr << endl;
				delete _ptr;
				_ptr = nullptr;
			}
		}
		//可以像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		//防拷贝
		unique_ptr(unique_ptr<T>& up) = delete;
		unique_ptr& operator=(unique_ptr<T>& up) = delete;
	private:
		T* _ptr; //管理的资源
	};
}

2. shared_ptr

引用计数

shared_ptr是C++11中引入的智能指针，shared_ptr通过引用计数的方式解决智能指针的拷贝问题。

  • 每一个被管理的资源都有一个对应的引用计数，通过这个引用计数记录着当前有多少个对象在管理着这块资源。
  • 当新增一个对象管理这块资源时则将该资源对应的引用计数进行++，当一个对象不再管理这块资源或该对象被析构时则将该资源对应的引用计数进行--。
  • 当一个资源的引用计数减为0时说明已经没有对象在管理这块资源了，这时就可以将该资源进行释放了。

通过这种引用计数的方式就能支持多个对象一起管理某一个资源，也就是支持了智能指针的拷贝，并且只有当一个资源对应的引用计数减为0时才会释放资源，因此保证了同一个资源不会被释放多次。比如：

int main()
{
	cl::shared_ptr<int> sp1(new int(1));
	cl::shared_ptr<int> sp2(sp1);
	*sp1 = 10;
	*sp2 = 20;
	cout << sp1.use_count() << endl; //2

	cl::shared_ptr<int> sp3(new int(1));
	cl::shared_ptr<int> sp4(new int(2));
	sp3 = sp4;
	cout << sp3.use_count() << endl; //2
	return 0;
}

说明一下： use_count成员函数，用于获取当前对象管理的资源对应的引用计数。

shared_ptr的模拟实现

简易版的shared_ptr的实现步骤如下：

  1. 在shared_ptr类中增加一个成员变量count，表示智能指针对象管理的资源对应的引用计数。
  2. 在构造函数中获取资源，并将该资源对应的引用计数设置为1，表示当前只有一个对象在管理这个资源。
  3. 在拷贝构造函数中，与传入对象一起管理它管理的资源，同时将该资源对应的引用计数++。
  4. 在拷贝赋值函数中，先将当前对象管理的资源对应的引用计数--（如果减为0则需要释放），然后再与传入对象一起管理它管理的资源，同时需要将该资源对应的引用计数++。
  5. 在析构函数中，将管理资源对应的引用计数--，如果减为0则需要将该资源释放。
  6. 对*和->运算符进行重载，使shared_ptr对象具有指针一样的行为。

代码如下：

namespace dianxia
{
	template<class T>
	class shared_ptr
	{
	public:
		//RAII
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}
		~shared_ptr()
		{
			if (--(*_pcount) == 0)
			{
				if (_ptr != nullptr)
				{
					cout << "delete: " << _ptr << endl;
					delete _ptr;
					_ptr = nullptr;
				}
				delete _pcount;
				_pcount = nullptr;
			}
		}
		shared_ptr(shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
		{
			(*_pcount)++;
		}
		shared_ptr& operator=(shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr) //管理同一块空间的对象之间无需进行赋值操作
			{
				if (--(*_pcount) == 0) //将管理的资源对应的引用计数--
				{
					cout << "delete: " << _ptr << endl;
					delete _ptr;
					delete _pcount;
				}
				_ptr = sp._ptr;       //与sp对象一同管理它的资源
				_pcount = sp._pcount; //获取sp对象管理的资源对应的引用计数
				(*_pcount)++;         //新增一个对象来管理该资源，引用计数++
			}
			return *this;
		}
		//获取引用计数
		int use_count()
		{
			return *_pcount;
		}
		//可以像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;      //管理的资源
		int* _pcount; //管理的资源对应的引用计数
	};
}

为什么引用计数需要存放在堆区？

首先，shared_ptr中的引用计数count不能单纯的定义成一个int类型的成员变量，因为这就意味着每个shared_ptr对象都有一个自己的count成员变量，而当多个对象要管理同一个资源时，这几个对象应该用到的是同一个引用计数。

如下图：

在这里插入图片描述

其次，shared_ptr中的引用计数count也不能定义成一个静态的成员变量，因为静态成员变量是所有类型对象共享的，这会导致管理相同资源的对象和管理不同资源的对象用到的都是同一个引用计数。

如下图：

在这里插入图片描述

而如果将shared_ptr中的引用计数count定义成一个指针，当一个资源第一次被管理时就在堆区开辟一块空间用于存储其对应的引用计数，如果有其他对象也想要管理这个资源，那么除了将这个资源给它之外，还需要把这个引用计数也给它。

这时管理同一个资源的多个对象访问到的就是同一个引用计数，而管理不同资源的对象访问到的就是不同的引用计数了，相当于将各个资源与其对应的引用计数进行了绑定。

如下图：

在这里插入图片描述

但同时需要注意，由于引用计数的内存空间也是在堆上开辟的，因此当一个资源对应的引用计数减为0时，除了需要将该资源释放，还需要将该资源对应的引用计数的内存空间进行释放。

3. 循环引用

shared_ptr看着很完美，但是其存在一个循环引用的问题，我们来看看循环引用是怎么出现的吧~

首先我们要引入一下双向链表中节点：

struct Node
{
	int _val;
	Node* _next;
	Node* _prev;
	~Node()
	{
		cout << "~Node()" << endl;
	}
};

这是使用普通指针的写法，现在我们将其中的普通指针全部改为shared_ptr：

struct shared_Node
{
	int _val;
	std::shared_ptr<shared_Node> _next;
	std::shared_ptr<shared_Node> _prev;
	~shared_Node()
	{
		cout << "~shared_Node()" << endl;
	}
};

这样一个由智能指针创建的双向链表节点就构建好了。

然后我们创建两个节点将其链接起来。

void test_shared_ptr2()
{
	std::shared_ptr<shared_Node> sn1(new shared_Node);
	std::shared_ptr<shared_Node> sn2(new shared_Node);
 
	sn1->_next = sn2;
	sn2->_prev = sn1;
}

此时没有任何问题，接下来我们运行一下观察结果：

在这里插入图片描述

发现，为什么我们使用shared_ptr在程序结束的时候没有调用shared_ptr的析构函数？按理来说控制台应该会输出两行 “~shared_Node()” 才对。

接下来我们画图来分析一下两个节点的关系：

在这里插入图片描述

然后当我们程序结束，sn1和sn2智能指针调用各自的析构函数后，其计数器的改变为：

在这里插入图片描述

所以，循环引用导致资源未被释放的原因：

  • 当资源对应的引用计数减为0时对应的资源才会被释放，因此节点1的释放取决于节点2当中的prev成员，而节点2的释放取决于节点1当中的next成员。
  • 而节点1当中的next成员的释放又取决于节点1，节点2当中的prev成员的释放又取决于节点2，于是这就变成了一个死循环，最终导致资源无法释放。

而如果连接结点时只进行一个连接操作，那么当node1和node2的生命周期结束时，就会有一个资源对应的引用计数被减为0，此时这个资源就会被释放，这个释放后另一个资源的引用计数也会被减为0，最终两个资源就都被释放了，这就是为什么只进行一个连接操作时这两个结点就都能够正确释放的原因。

4. weak_ptr

解决循环引用问题

weak_ptr是C++11中引入的智能指针，weak_ptr不是用来管理资源的释放的，它主要是用来解决shared_ptr的循环引用问题的。

  • weak_ptr支持用shared_ptr对象来构造weak_ptr对象，构造出来的weak_ptr对象与shared_ptr对象管理同一个资源，但不会增加这块资源对应的引用计数。

将ListNode中的next和prev成员的类型换成weak_ptr就不会导致循环引用问题了，此时当node1和node2生命周期结束时两个资源对应的引用计数就都会被减为0，进而释放这两个结点的资源。比如：

struct ListNode
{
	std::weak_ptr<ListNode> _next;
	std::weak_ptr<ListNode> _prev;
	int _val;
	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};
int main()
{
	std::shared_ptr<ListNode> node1(new ListNode);
	std::shared_ptr<ListNode> node2(new ListNode);

	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	node1->_next = node2;
	node2->_prev = node1;
	//...
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}

通过use_count获取这两个资源对应的引用计数就会发现，在结点连接前后这两个资源对应的引用计数就是1，根本原因就是weak_ptr不会增加管理的资源对应的引用计数。

weak_ptr的模拟实现

简易版的weak_ptr的实现步骤如下：

  1. 提供一个无参的构造函数，比如刚才new ListNode时就会调用weak_ptr的无参的构造函数。
  2. 支持用shared_ptr对象拷贝构造weak_ptr对象，构造时获取shared_ptr对象管理的资源。
  3. 支持用shared_ptr对象拷贝赋值给weak_ptr对象，赋值时获取shared_ptr对象管理的资源。
  4. 对*和->运算符进行重载，使weak_ptr对象具有指针一样的行为。

代码如下：

namespace dianxia
{
	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{}
		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp.get())
		{}
		weak_ptr& operator=(const shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			return *this;
		}
		//可以像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr; //管理的资源
	};
}

说明一下： shared_ptr还会提供一个get函数，用于获取其管理的资源。

5. 定制删除器

定制删除器的用法

当智能指针对象的生命周期结束时，所有的智能指针默认都是以delete的方式将资源释放，这是不太合适的，因为智能指针并不是只管理以new方式申请到的内存空间，智能指针管理的也可能是以new[]的方式申请到的空间，或管理的是一个文件指针。比如：

struct ListNode
{
	ListNode* _next;
	ListNode* _prev;
	int _val;
	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};
int main()
{
	std::shared_ptr<ListNode> sp1(new ListNode[10]);   //error
	std::shared_ptr<FILE> sp2(fopen("test.cpp", "r")); //error

	return 0;
}

这时当智能指针对象的生命周期结束时，再以delete的方式释放管理的资源就会导致程序崩溃，因为以new[]的方式申请到的内存空间必须以delete[]的方式进行释放，而文件指针必须通过调用fclose函数进行释放。

这时就需要用到定制删除器来控制释放资源的方式，C++标准库中的shared_ptr提供了如下构造函数：

template <class U, class D>
shared_ptr (U* p, D del);

参数说明：

  • p：需要让智能指针管理的资源。
  • del：删除器，这个删除器是一个可调用对象，比如函数指针、仿函数、lambda表达式以及被包装器包装后的可调用对象。

当shared_ptr对象的生命周期结束时就会调用传入的删除器完成资源的释放，调用该删除器时会将shared_ptr管理的资源作为参数进行传入。

因此当智能指针管理的资源不是以new的方式申请到的内存空间时，就需要在构造智能指针对象时传入定制的删除器。比如：

template<class T>
struct DelArr
{
	void operator()(const T* ptr)
	{
		cout << "delete[]: " << ptr << endl;
		delete[] ptr;
	}
};
int main()
{
	std::shared_ptr<ListNode> sp1(new ListNode[10], DelArr<ListNode>());
	std::shared_ptr<FILE> sp2(fopen("test.cpp", "r"), [](FILE* ptr){
		cout << "fclose: " << ptr << endl;
		fclose(ptr);
	});

	return 0;
}

定制删除器的模拟实现

定制删除器的实现问题：

  • C++标准库中实现shared_ptr时是分成了很多个类的，因此C++标准库中可以将删除器的类型设置为构造函数的模板参数，然后将删除器的类型在各个类之间进行传递。
  • 但我们是直接用一个类来模拟实现shared_ptr的，因此不能将删除器的类型设置为构造函数的模板参数。因为删除器不是在构造函数中调用的，而是需要在ReleaseRef函数中进行调用，因此势必需要用一个成员变量将删除器保存下来，而在定义这个成员变量时就需要指定删除器的类型，因此这里模拟实现的时候不能将删除器的类型设置为构造函数的模板参数。
  • 要在当前模拟实现的shared_ptr的基础上支持定制删除器，就只能给shared_ptr类再增加一个模板参数，在构造shared_ptr对象时就需要指定删除器的类型。然后增加一个支持传入删除器的构造函数，在构造对象时将删除器保存下来，在需要释放资源的时候调用该删除器进行释放即可。最好在设置一个默认的删除器，如果用户定义shared_ptr对象时不传入删除器，则默认以delete的方式释放资源。

代码如下：

namespace dianxia
{
	//默认的删除器
	template<class T>
	struct Delete
	{
		void operator()(const T* ptr)
		{
			delete ptr;
		}
	};
	template<class T, class D = Delete<T>>
	class shared_ptr
	{
	private:
		void ReleaseRef()
		{
			_pmutex->lock();
			bool flag = false;
			if (--(*_pcount) == 0) //将管理的资源对应的引用计数--
			{
				if (_ptr != nullptr)
				{
					cout << "delete: " << _ptr << endl;
					_del(_ptr); //使用定制删除器释放资源
					_ptr = nullptr;
				}
				delete _pcount;
				_pcount = nullptr;
				flag = true;
			}
			_pmutex->unlock();
			if (flag == true)
			{
				delete _pmutex;
			}
		}
		//...
	public:
		shared_ptr(T* ptr, D del)
			: _ptr(ptr)
			, _pcount(new int(1))
			, _pmutex(new mutex)
			, _del(del)
		{}
		//...
	private:
		T* _ptr;        //管理的资源
		int* _pcount;   //管理的资源对应的引用计数
		mutex* _pmutex; //管理的资源对应的互斥锁
		D _del;         //管理的资源对应的删除器
	};
}

这时我们模拟实现的shared_ptr就支持定制删除器了，但是使用起来没有C++标准库中的那么方便。

  • 如果传入的删除器是一个仿函数，那么需要在构造shared_ptr对象时指明仿函数的类型。
  • 如果传入的删除器是一个lambda表达式就更麻烦了，因为lambda表达式的类型不太容易获取。这里可以将lambda表达式的类型指明为一个包装器类型，让编译器传参时自行进行推演，也可以先用auto接收lambda表达式，然后再用decltype来声明删除器的类型。
template<class T>
struct DelArr
{
	void operator()(const T* ptr)
	{
		cout << "delete[]: " << ptr << endl;
		delete[] ptr;
	}
};
int main()
{
	//仿函数示例
	cl::shared_ptr<ListNode, DelArr<ListNode>> sp1(new ListNode[10], DelArr<ListNode>());

	//lambda示例1
	cl::shared_ptr<FILE, function<void(FILE*)>> sp2(fopen("test.cpp", "r"), [](FILE* ptr){
		cout << "fclose: " << ptr << endl;
		fclose(ptr);
	});

	//lambda示例2
	auto f = [](FILE* ptr){
		cout << "fclose: " << ptr << endl;
		fclose(ptr);
	};
	cl::shared_ptr<FILE, decltype(f)> sp3(fopen("test.cpp", "r"), f);

	return 0;
}

五.总结

智能指针常见考点：

  1. 为什么需要智能指针？

忘记释放/异常跳转安全

  1. RAII是什么

将资源交给对象去管理

  1. 智能指针的发展历史

  2. auto_ptr、unique_ptr、shared_ptr、weak_ptr之间的区别和使用场景

  3. 模拟实现各种智能指针

  4. 什么是循环引用，如何解决？解决的原理是什么？

  5. 为什么要使用定制删除器，写个demo。

殿下p
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++11智能指针
01-06
智能指针  智能指针是行为类似于指针的类对象。可以帮助管理动态内存分配。普通指针分配内存后都必须释放内存 new 之后需要使用 delete 否则内存泄漏。智能指针类对象封装了自动释放内存的功能 从而避免内存泄漏 ...
C++11 智能指针
zoutaofen的博客
04-27 1519
文章目录前言一、智能指针是什么？二、基本用法1.shared_ptr初始化获取原始指针指定删除器shared_ptr的坑2.unique_ptrunique_ptr基本用法自定义make_unique创建unique_ptrunique_ptr与shared_ptr的区别自定义unique_ptr删除器weak_ptrweak_ptr基本用法weak_ptr返回this指针weak_ptr解决循环引用问题通过智能指针管理第三方库分配的内存总结 前言 C++11标准为C++增加了许多新的特性。常用的特性。如
c++11 智能指针
大菜菜的博客
11-22 4286
一、智能指针 c++程序设计中经常会用堆内存，程序员要自己管理内存的申请和释放。使用原始指针，容易造成堆内存泄漏（忘记释放），二次释放；使用智能指针能更好的管理堆内存。 c++中四个智能指针：auto_ptr，unique_ptr，shared_ptr，weak_ptr，auto_ptr已被c++11弃用 头文件 #include <memory> 1. shared_ptr（共享的智能指针） 1）定义：允许多个指针指向同一个对象，内部维护一个计数器，无论何时拷贝一个shared_ptr，计数器
C++11智能指针
嵌入式开发记录
01-05 865
在初始化 shared_ptr 智能指针时，还可以自定义所指堆内存的释放规则，这样当堆内存的引用计数为 0 时，会优先调用我们自定义的释放规则。在某些场景中，自定义释放规则是很有必要的。比如，对于申请的动态数组来说，shared_ptr 指针默认的释放规则是不支持释放数组的，只能自定义对应的释放规则，才能正确地释放申请的堆内存。//指定 default_delete 作为释放规则//自定义释放规则} //初始化智能指针，并自定义释放规则});
C++ 11智能指针详解和使用
疯狂挖掘机的博客
09-21 1426
C++11中的智能指针的初步学习
C++11之智能指针
12-22
使用c++，除了c++的语法外，指针是我们面临的的大一个问题，由于使用不当会导致程序意外退出，或着内存的占用越来越多，总结起来这些错误由以下三个原因造成。 　1 野指针：指针指向的内存已经被释放，但是我们还在...
使用C++11智能指针时要避开的10大错误
12-22
我很喜欢新的C++11的智能指针。在很多时候，对很多讨厌自己管理内存的人来说是天赐的礼物。在我看来，C++11的智能指针能使得C++新手教学更简单。 　其实，我已经使用C++11两年多了，我无意中发现多种错误使用C++11...
c++11&14-智能指针要点汇总
12-17
但像java等其他一些语言则不会有这样的问题，为什么呢，因为它们有很好的处理内存的方法，比如java的垃圾回收机制，现在，我们c++终于也有了智能指针。 1. 什么是智能指针 简单地说，智能指针是用对象去管理一个...
C++11智能指针之weak_ptr详解
01-19
如题，我们今天要讲的是 C++11 引入的三种智能指针中的：weak_ptr。 在学习 weak_ptr 之前最好对 shared_ptr 有所了解。如果你还不知道 shared_ptr 是何物，可以看看另一篇文章： 【C++11新特性】 C++11智能指针之...
【C++第三阶段】list容器&排序
还有很多需要学习，现在还很菜
04-29 669
以下内容仅为当前认识，可能有不足之处，欢迎讨论！
《21天学通C++》（第十章）实现继承（1）
立志成为炼丹师？
04-28 272
覆盖是一种极端情况，即派生类中的重载方法会隐藏基类中方法的所有重载版本，导致需要调用时无法调用，示例代码如下。解决方法3：在派生类中，把基类中的方法全部重载一次，并在派生类中就调用基类方法。只要派生类中实现了从基类中继承的函数，且返回值和标值相同，就可以覆盖。如果基类包含重载的构造函数，可以使用初始化列表传递参数。，避免不定义的情况下，随机数值产生影响。解决办法1：使用作用域解析符。解决方法2：在派生类中使用。同样使用作用域解析运算符。在构造一个派生类时，使用作用域解析运算符。若想调用基类中的方法。
C++ Primer (第五版）第八章习题部分答案
weixin_48467622的博客
04-27 1068
C++ Primer (第五版）第八章习题部分答案
c入门基础题（3）
梦昼初
04-26 963
1、找出数组中最大元素的位置（下标值） 输入 多组测试，每组先输入一个不大于10的整数n 然后是n个整数 输出 输出这n个整数中最大的元素及下标值 样例输入 4 1 4 5 6 样例输出 6 3 #include<stdio.h> int main(){ int a[20]; int n,x=0,y,z,s,m,f; int i,j; while(scanf("%d",&n)!=EOF){ for(i=1;i<=n;i++){ scanf("%d",&y)
C++相关概念和易错语法（9）（变量的存储、new和delete混用分析）
SGlow0708的博客
04-28 747
我们发现如果这个时候直接去调用operator delete[]、operator delete、delete、free就会导致释放的内存起始位置发生了位移，这就会导致报错，而delete[]就会先从前4个字节开始，先读取个数，然后。注意数组是开辟了空间的，会发生复制操作，就算是常量字符串储存在代码段，也要拷贝过来。如果类没有显式实现析构函数，那么就意味着不会多开辟那4个字节，也就不会报错，这个时候混用不会导致程序崩溃。当我们创建类的数组时，使用new[]，因为使用它可以在开辟空间的时候。
迭代器iterator是C++中用于遍历容器中元素的对象
book_dw5189的博客
04-28 808
迭代器的使用通常伴随着容器的.begin()和.end()成员函数，这两个函数分别返回指向容器第一个元素和尾后元素的迭代器。
【C++】const修饰输入参数
zjh2883的博客
04-28 185
在这个例子中，printValue函数的参数被声明为const，这意味着函数内部不会修改value的值。如果尝试修改value，编译器将会报错，从而避免了潜在的bug。在C++中，传参时使用const可以防止在函数内部不小心修改了传入的参数，这样可以提高代码的健壮性和可维护性。const表示函数内部不会修改传入的参数。，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const修饰。,那么加const修饰可以防止意外地改动该指针，起到保护作用。
使用C++和QT开发第一款跨平台桌面应用程序
最新发布
Python私教
05-03 316
跨平台的C++图形用户界面（GUI）应用程序开发框架。QT专注但不局限于图形用户界面的开发，其他也包括系统调用，网络编程，数据库编程，2D，3D图形处理等。QT支持各大主流的操作系统，比如Linux，Windows，macOS，Android，iOS等。
【C++】析构函数的作用及其使用
原小明
04-28 589
当一个对象的生命周期结束时，无论是对象所在的作用域结束（例如，局部对象在函数退出时）、对象被delete（针对动态分配的对象）、或者容器（如std::vector）自动销毁其元素时，析构函数都会被自动调用。在继承关系中，当派生类的析构函数执行完毕后，基类的析构函数会被自动调用，确保了基类资源的正确释放。同样，如果一个类包含了另一个类的对象作为成员，那么当该类的析构函数被调用时，成员对象的析构函数也会被自动调用，递归地清理整个对象结构。然而，对于管理了资源的类，最好显式定义析构函数以确保资源的正确清理。
c++11智能指针面试题
01-03
以下是一个关于C++11智能指针的面试题的示例： ```cpp #include <iostream> #include <memory> class MyClass { public: MyClass() { std::cout << "MyClass constructor called" << std::endl; } ~MyClass() { std::cout << "MyClass destructor called" << std::endl; } void doSomething() { std::cout << "Doing something" << std::endl; } }; int main() { std::shared_ptr<MyClass> ptr1(new MyClass); std::shared_ptr<MyClass> ptr2 = ptr1; ptr1->doSomething(); ptr2->doSomething(); return 0; } ``` 这个示例演示了如何使用C++11中的`std::shared_ptr`智能指针。在这个示例中，我们创建了一个`MyClass`类的实例，并使用`std::shared_ptr`来管理它的内存。当`ptr1`和`ptr2`都指向同一个对象时，该对象的引用计数为2。当其中一个指针超出作用域时，引用计数减少，直到引用计数为0时，对象的析构函数被调用，内存被释放。 输出结果： ``` MyClass constructor called Doing something Doing something MyClass destructor called ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

殿下p

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值