脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → C 语言 → C++11 智能指针

C++11 智能指针的具体使用

 更新时间：2021年08月24日 11:06:06   作者：Reset。  
本文主要介绍了C++11 智能指针的具体使用，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

智能指针的原理

RAII

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

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

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

我们使用RAII的思想设计SmartPtr类：

template <class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

    ~SmartPtr()
	{
		if (_ptr)
		{
			delete _ptr;
			_ptr = nullptr;
		}
	}

private:
	T* _ptr;
};

智能指针的原理

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

template <class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

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

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

    ~SmartPtr()
	{
		if (_ptr)
		{
			delete _ptr;
			_ptr = nullptr;
		}
	}

private:
	T* _ptr;
};

智能指针使用：

在这里插入图片描述

总结智能指针的原理：

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

auto_ptr

1.auto_ptr的使用及问题

auto_ptr的头文件#include<memory>

auto_ptr的使用：

在这里插入图片描述

在这里插入图片描述

为什么此时访问sp的成员时会报错呢？我们来看看它们的地址。

在这里插入图片描述

我们发现在拷贝构造之后，sp管理的地址为空，而sp1管理的地址是之前sp所管理的地址，管理权发生了转移。那么上面所说的报错也很容易想通，因为sp管理的地址为空，不能进行访问。

auto_ptr的问题：当对象拷贝或者赋值后，管理权进行转移，造成前面的对象悬空。auto_ptr问题是非常明显的，所以实际中很多公司明确规定了不能使用auto_ptr。

auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份AutoPtr来了解它的原理：

template<class T>
class AutoPtr
{
public:
	AutoPtr(T* ptr)
		:_ptr(ptr)
	{}

	//拷贝：管理权转移
	AutoPtr(AutoPtr<T> &sp)
		:_ptr(sp._ptr)
	{
		sp._ptr = nullptr;
	}

	//赋值：管理权转移
	AutoPtr& operator=(AutoPtr<T> &sp)
	{
		if (this != &sp)
		{
			if (_ptr)
				delete _ptr;
			_ptr = sp._ptr;
			sp._ptr = nullptr;
		}
		return *this;
	}

	~AutoPtr()
	{
		if (_ptr)
		{
			delete _ptr;
			_ptr = nullptr;
		}
	}

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

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

private:
	T* _ptr;
};

unique_ptr

为了解决拷贝或者赋值时管理权转移的问题，出现了unique_ptr。

unique_ptr解决问题的方式非常粗暴：防拷贝，也就是不让赋值和拷贝

unique_ptr的使用：

在这里插入图片描述

unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理：

template<class T>
class UniquePtr
{
public:

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

	// C++11防拷贝的方式：delete
	UniquePtr(const UniquePtr<T> &) = delete;

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

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

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

	~UniquePtr()
	{
		if (_ptr)
		{
			delete _ptr;
			_ptr = nullptr;
		}
	}

private:

	//C++98防拷贝的方式：只声明不实现+声明成私有
	//UniquePtr(UniquePtr<T> const &);
	//UniquePtr& operator=(UniquePtr<T> const &);

	T* _ptr;
};

shared_ptr

c++11中提供更靠谱的并且支持拷贝的shared_ptr

shared_ptr的使用

在这里插入图片描述

shared_ptr中拷贝与赋值都是没有问题的。

shared_ptr的原理

  • shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
  • 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
  • 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
  • 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

shared_ptr中成员函数：use_count（对象数据的引用计数）

示例：

在这里插入图片描述

示例详解：

在这里插入图片描述

利用引用计数简单的实现SharedPtr，了解原理：

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

	SharedPtr(const SharedPtr<T> &sp)
		:_ptr(sp._ptr)
		,_count(sp._count)
	{
		//计数器累加
		++(*_count);
	}

	SharedPtr& operator=(const SharedPtr<T> &sp)
	{
		//判断管理的是否是同一份资源
		if (_ptr != sp._ptr)
		{
			//计数-1，判断之前管理的资源是否需要释放
			if ((--(*_count)) == 0)
			{
				delete _ptr;
				delete _count;
			}
			
			_ptr = sp._ptr;
			_count = sp._count;

			//计数器累加
			++(*_count);
		}
		return *this;
	}

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

	~SharedPtr()
	{
		if (--(*_count) == 0)
		{
			delete _ptr;
			delete _count;
			_ptr = nullptr;
			_count = nullptr;
		}
	}

private:
	T* _ptr;
	int* _count;//给每份资源开辟一个计数器
};

但是还存在一个线程安全的问题：

  1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或–，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2。这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数++、- -是需要加锁的，也就是说引用计数的操作是线程安全的。
  2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。

这里我们通过加锁来解决线程安全问题：

template<class T>
class SharedPtr
{
public:
	SharedPtr(T* ptr)
		:_ptr(ptr)
		,_count(new int(1))
		,_mutex(new mutex)
	{}

	SharedPtr(const SharedPtr<T> &sp)
		:_ptr(sp._ptr)
		,_count(sp._count)
		,_mutex(sp._mutex)
	{
		//计数器累加
		AddCount();
	}

	SharedPtr& operator=(const SharedPtr<T> &sp)
	{
		//判断管理的是否是同一份资源
		if (_ptr != sp._ptr)
		{
			//计数-1，判断之前管理的资源是否需要释放
			if (SubCount() == 0)
			{
				delete _ptr;
				delete _count;
				delete _mutex;
			}
			
			_ptr = sp._ptr;
			_count = sp._count;
			_mutex = sp._mutex;

				//计数器累加
			AddCount();
		}
		return *this;
	}

	//线程安全的累加器
	int AddCount()
	{
		//加锁
		_mutex->lock();
		++(*_count);
		_mutex->unlock();
		return *_count;
	}

	int SubCount()
	{
		_mutex->lock();
		--(*_count);
		_mutex->unlock();
		return *_count;
	}

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

	~SharedPtr()
	{
		if (SubCount() == 0)
		{
			delete _ptr;
			delete _count;
			delete _mutex;
			_ptr = nullptr;
			_count = nullptr;
			_mutex = nullptr;
		}
	}
	
private:
	T* _ptr;
	int* _count;//给每份资源开辟一个计数器
	mutex* _mutex; //每一份资源有一个独立的锁
};

shared_ptr的循环引用

循环引用的场景：

struct ListNode
{
	int _data; 
    shared_ptr<ListNode> _prev;
	shared_ptr<ListNode> _next;
	~ListNode() { cout << "~ListNode()" << endl; }
};

void test()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);

	node1->_next = node2;
	node2->_prev = node1;
}

在这里插入图片描述

node1和node2两个智能指针对象指向两个节点，两个节点的引用计数都是1。node1->next指向node2，node2->prev指向node1，两个节点的引用计数都变成2。程序运行完之后，析构node1和node2，node1和node2所指向的节点引用计数分别减1，但是node1->next指向下面节点，node2->prev指向上面节点，此时，两个节点的引用计数都为1，所以两个节点不能析构。

引用计数为0时，如果要析构node1节点，就先要去析构node1中的自定义结构，然后再析构node1。也就是说node1->next析构了，node2就释放了；node2->prev析构了，node1就释放了。但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。

解决方案：
在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了
原理就是，node1->_next = node2和node2->_prev = node1时weak_ptr的_next和_prev不会增加node1和node2的引用计数。

weak_ptr最大作用就是解决shared_ptr的循环引用

struct ListNode
{
	int _data; 
    weak_ptr<ListNode> _prev;
	weak_ptr<ListNode> _next;
	~ListNode() { cout << "~ListNode()" << endl; }
};
void test()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);

	node1->_next = node2;
	node2->_prev = node1;
}

注意：
weak_ptr不能单独使用，可以用shared_ptr创建

	//weak_ptr错误使用
	weak_ptr<ListNode> node1(new ListNode);

	//weak_ptr正确使用
	shared_ptr<ListNode> node2(new ListNode);
	weak_ptr<ListNode> node3(node2);

到此这篇关于C++11 智能指针的具体使用的文章就介绍到这了,更多相关C++11 智能指针内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • C++将字符串格式化的几种方式总结

    C++将字符串格式化的几种方式总结

    这篇文章主要介绍了C++将字符串格式化的几种方式总结，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2023-01-01
  • 基于C语言实现简单的五子棋游戏

    基于C语言实现简单的五子棋游戏

    这篇文章主要为大家详细介绍了基于C语言实现简单的五子棋游戏，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2022-05-05
  • 数据结构之堆详解

    数据结构之堆详解

    这篇文章主要介绍了数据结构之堆详解,本文讲解了堆的基本常识堆的基本操作、堆的应用等内容,需要的朋友可以参考下
    2014-08-08
  • 解决C语言中使用scanf连续输入两个字符类型的问题

    解决C语言中使用scanf连续输入两个字符类型的问题

    这篇文章主要介绍了解决C语言中使用scanf连续输入两个字符类型的问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2020-12-12
  • C语言超详细讲解猜数字游戏的实现

    C语言超详细讲解猜数字游戏的实现

    现在很多游戏都有抽奖抽卡的功能，其实这个就类似于猜数字，生成一个随机数，然后你去猜，猜对了就得奖。猜到一定次数就会保底。要实现猜数字的小游戏，首先是要让程序生成随机数，这就要用到rand、srand和time这三个函数，其次要了解时间戳
    2022-07-07
  • C语言算法练习之数组元素排序

    C语言算法练习之数组元素排序

    这篇文章主要为大家介绍了C语言算法练习中数组元素排序的实现方法，文中的示例代码讲解详细，对我们学习C语言有一定帮助，需要的可以参考一下
    2022-09-09
  • C语言中的结构体的入门学习教程

    C语言中的结构体的入门学习教程

    这篇文章主要介绍了C语言中的结构体的入门学习教程,以struct语句定义的结构体是C语言编程中的重要基础,需要的朋友可以参考下
    2015-12-12
  • C++之openFrameworks框架介绍

    C++之openFrameworks框架介绍

    本章我们将介绍一个非常好用的跨平台的 C++开源框架 openFrameworks。它是一个开源的跨平台的C++工具包，方便开发者创建出一个更简单和直观的框架，擅长开发图像和动画，感兴趣的同学可以参考一下
    2023-05-05
  • 一篇文章带你掌握C++虚函数的来龙去脉

    一篇文章带你掌握C++虚函数的来龙去脉

    虚函数主要通过V-Table虚函数表来实现,该表主要包含一个类的虚函数的地址表,可解决继承、覆盖的问题,下面这篇文章主要给大家介绍了如何通过一篇文章带你掌握C++虚函数的来龙去脉,需要的朋友可以参考下
    2022-10-10
  • C语言中getchar()的返回类型为什么是int详解

    C语言中getchar()的返回类型为什么是int详解

    这篇文章主要给大家介绍了关于C语言中getchar()的返回类型为什么是int的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2018-11-11

最新评论