【C++11 面试】深剖智能指针(下篇) , 代码 + 图解让你彻底理解 , 面试重要重要重要 !

前言

本篇文章接续上篇内容 , 本篇章将会对 shared_ptr 以及 循环引用 、weak_ptr 进行详细讲解 , 这部分很重要 , 划为面试中的重点内容 !

一、引用计数

笔者在上篇中提到了 , shared_ptr , 这里回顾 .

那么什么是引用计数呢 ?

1 . 介绍

引用计数是计算机编程语言中的一种内存管理技术，是指将资源（可以是对象、内存或磁盘空间等等）的被引用次数保存起来，当被引用次数变为零时就将其释放的过程。

2 . 引用计数的好处是什么 ?

所以 , 引用计数可以很好的解决问题 !

二、shared_ptr (极其极其重要)

1 . 引用计数的设计

这里一份资源就要一个引用计数来记录 , 那么引用计数是要动态变化的 , 所以这里的实现采用的是堆上的动态开辟 . 即 : 构造智能指针对象时 , new 一个引用计数出来 . 多个资源指向时就 ++引用计数 .

2. 实现 shared_ptr (面试版)

非常重要 , 必须会手撕 .

• 基本框架

template <class T>
class shared_ptr
{
	public:

	private:
		T* _ptr; // 资源
		int* pcount; // 引用计数 , 动态开辟
};

• 构造函数

RAII 思想 , 来一份资源初始化智能指针对象 , 交给对象管理 .

//RAII , 构造对象 , 来一份新的资源就申请一个引用计数 , 用来记录这块
//资源后续被几个对象管理
//构造时不允许隐式类型转换 , 用 explicit 
explicit shared_ptr(T* ptr = nullptr)
	:_ptr(ptr)
	,_pcount(new int(1)) // 来 1个资源,初始被 1 个管理
{}

• 拷贝构造

//拷贝构造 - 浅拷贝资源给我 , 我指向你
//注意这里是模版 , 类型是 shared_ptr<T>
shared_ptr(const shared_ptr<T>& sp)
	:_ptr(sp._ptr)
	,_pcount(sp._pcount)
{
	//你和我指向同一资源 , 我的引用计数已经指向你的引用计数 , ++引用计数
	++(*_pcount);
}

• 赋值重载

//赋值重载
 //s2 = s3 , s3 赋值给了 s2 , 即 s2 指向了 s3
//类型是 shared_ptr<T>
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
	//防止自我赋值 , 这么写
	if (_ptr != sp._ptr)
	{
		//因为我的要指向别人 , 先--我的引用计数
		//若我的引用计数 = 0 , 我的资源就可以释放了
		//否则我不用管
		if (--(*_pcount) == 0)
		{
			//我的资源要释放
			delete _ptr;
			delete _pcount;
			_ptr = _pcount = nullptr;
		}

		//我直接指向别人的资源 ,我原来的资源不用动
		_ptr = sp._ptr;
		_pcount = sp._pcount;
		//++别人的引用计数, 因为我指向了别人
		//我的引用计数已经指向别人的引用计数了
		++(*_pcount);
	}
	
		return *this;
}

• 要像指针一样

//像指针一样
T& operator*()
{
	return *_ptr;
}

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

● 完整代码

template <class T>
class shared_ptr
{
public:

	//RAII , 构造对象 , 来一份新的资源就申请一个引用计数 , 用来记录这块
	//资源后续被几个对象管理
	//构造时不允许隐式类型转换
	explicit shared_ptr(T* ptr = nullptr)
		:_ptr(ptr)
		,_pcount(new int(1)) // 来 1个资源,初始被 1 个管理
	{}

	////拷贝构造 - 浅拷贝资源给我 , 我++引用计数
	//注意这里是模版 , 类型是 shared_ptr<T>
	shared_ptr(const shared_ptr<T>& sp)
		:_ptr(sp._ptr)
		,_pcount(sp._pcount)
	{
		//你和我指向同一资源 , 我的++引用计数
		++(*_pcount);
	}

	//赋值重载
	 //s2 = s3 , s3 赋值给了 s2 , 即 s2 指向了 s3
	//类型是 shared_ptr<T>
	shared_ptr<T>& operator=(const shared_ptr<T>& sp)
	{
		//防止自我赋值 , 这么写
		if (_ptr != sp._ptr)
		{
			//因为我的要指向别人 , 先--我的引用计数
			//若我的引用计数 = 0 , 我的资源就可以释放了
			//否则我不用管
			if (--(*_pcount) == 0)
			{
				//我的资源要释放
				delete _ptr;
				delete _pcount;
				_ptr = _pcount = nullptr;
			}

			//我直接指向别人的资源 ,我原来的资源不用动
			_ptr = sp._ptr;
			_pcount = sp._pcount;
			//++别人的引用计数, 因为我指向了别人
			//我的引用计数已经指向别人的引用计数了
			++(*_pcount);
		}

		return *this;
	}

	//析构
	~shared_ptr()
	{
		//引用计数为 0 了 , 才去释放资源
		if (--(*_pcount) == 0)
		{
			delete _ptr;
			delete _pcount;
			_ptr = nullptr;
			_pcount = nullptr;
		}
	}

	int use_count() const 
	{
		return *_pcount;
	}


	//像指针一样
	T& operator*()
	{
		return *_ptr;
	}

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

private:
	T* _ptr; // 资源
	int* _pcount; // 引用计数 , 动态开辟
};

三、shared_ptr 的缺陷

即使 shared_ptr 好用 ,但是它还会有缺陷 , 这个缺陷就是会出现循环引用的问题 .

循环引用 (重要重要)

面试讲解时可以配图讲解 ~~~~~~

1 . 介绍

循环引用的情况比较极端 , 一般不会出现, 但一旦出现就致命 .

循环引用是指两个或多个对象相互引用，形成一个无法通过常规手段解除的引用链。

2 . 出现循环引用会发生什么 ?

3 . 什么情况下会出现循环引用 ?

这里笔者以以下代码为例讲解 :

#include <iostream>
using namespace std;

struct ListNode
{
    ListNode() {}

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

    int _data = 0;
    std::shared_ptr<ListNode> _prev;
    std::shared_ptr<ListNode> _next;
};

int main()
{
    //什么情况下会出现循环引用 ?
    std::shared_ptr<ListNode> p1(new ListNode);
    std::shared_ptr<ListNode> p2(new ListNode);

    cout << p1.use_count() << endl;
    cout << p2.use_count() << endl;

    //有这样的场景
    //箭头可以访问数据 , 数据是 ListNode , 就可以访问 ListNode 中的数据
    
    //ok , 智能指针可以赋值给智能指针
    p1->_next = p2;

    ////当互相指向时
    p2->_prev = p1;

    //发现内存泄漏了 

	return 0;
}

4. 循环引用详细分析

• 循环引用场景讲解这么讲(重要重要重要重要)

• 解决循环引用的方法

那针对这样的场景 , 该怎么办呢 ? 此时就要使用 weak_ptr 能够有效的解决循环引用的问题了 .

四、weak_ptr

文档出处 .

  
可以看到在 weak_ptr 中是没有直接指针进行构造的 , 也就是说 weak_ptr 没有去走 RAII 的思想了 .

从这里也可以看出 weak_ptr 也是不支持直接访问资源的 , 因为没有重载 * / -> .

1. weak_ptr原理 (重要)

2. weak_ptr 使用

• 基本使用 , 解决循序引用

#include <iostream>
using namespace std;

struct ListNode
{
    ListNode() {}

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

    int _data = 0;
    std::weak_ptr<ListNode> _prev;
    std::weak_ptr<ListNode> _next;
};

int main()
{
	//解决循环引用  --- weak_ptr
    std::shared_ptr<ListNode> p1(new ListNode);
    std::shared_ptr<ListNode> p2(new ListNode);

    cout << p1.use_count() << endl;
    cout << p2.use_count() << endl;

    //用 weak_ptr , 就不会影响 shared_ptr 的引用计数了
    //绑定 shared_ptr;
    // weak_ptr<ListNode> = shared_ptr<ListNode>
    p1->_next = p2;
    //weak_ptr<ListNode> = shared_ptr<ListNode>
    p2->_prev = p1;
	return 0;
}

• expired --检查指向的资源是否过期
• lock 可以支持间接访问

五、 思维导图总结

总结

以上就是智能指针部分所以内容 , 皆是笔者为了后续更好的复习所写 , 有错误的地方请及时指正 , 感兴趣的伙伴可以点赞 + 关注哦 ! ~~~~