C++11【智能指针详解】

最新推荐文章于 2023-08-03 10:08:15 发布
最新推荐文章于 2023-08-03 10:08:15 发布
阅读量986 收藏 1
点赞数 2
文章标签： c++ 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smf12138/article/details/127823235
版权

智能指针

🏞️1. 为什么引入智能指针？

我们来看这样一段代码：

#include <iostream>
using namespace std;

int div()
{
	int a, b;
	cin >> a >> b;

	if (b == 0)
	{
		throw "除0错误";
	}

	return a / b;
}

void func()
{
	int* p1 = new int;
	int* p2 = new int;

	cout << div() << endl;

	delete p1;
	delete p2;
}

int main()
{
	try
	{
		func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

在这段代码中，如果在div函数中发生了除0错误，我们在main函数捕获异常，那么最终异常抛出后会跳转到main函数中的catch处，对于p1和p2申请的资源就没有得到释放，就造成了内存泄露问题.

关于内存泄露介绍，在另一篇文章中有详细的介绍：

🌁2. 智能指针的使用及原理

📖2.1 RAII思想

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

获取到资源以后去初始化一个对象，将资源交给对象管理：资源获取即初始化

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

  1. 不需要显式的释放资源
  2. 采用这种方式，对象所需的资源在其生命周期内始终有效
//实现一个最简易的智能指针
template<class T>
class smart_ptr
{
public:
	smart_ptr(T* ptr = nullptr)
		: _ptr(ptr)
	{}
	
    //对象析构时自动释放所管理的资源
	~smart_ptr()
	{
		cout << "delete " << _ptr << endl;

		if (_ptr)
		{
			delete _ptr;
			_ptr = nullptr;
		}
	}
private:
	T* _ptr;
};

此时，我们使用智能指针来代替裸指针，并让它发生除0错误：

#include <iostream>
#include "smart_ptr.h"
using namespace std;

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;
}

image-20221108172706448

可以看到，刚才由于抛异常未能释放的资源现在可以正常释放.

📖2.2 智能指针的原理

我们所写的这个简单的智能指针smart_ptr还不能称其为智能指针，因为它还不具有指针的行为，指针可以解引用，可以通过->去访问所指向空间内的内容，所以为了让它向指针一样，我们还需重载*，->运算符.

template<class T>
class smart_ptr
{
public:
	smart_ptr(T* ptr = nullptr)
		: _ptr(ptr)
	{}

	~smart_ptr()
	{
		cout << "delete " << _ptr << endl;

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

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

	T* get() const
	{
		return _ptr;
	}

	T* operator->() const  //T*  = const T* _ptr
	{
		return _ptr;
	}
private:
	T* _ptr;
};

但是这样的智能指针是有问题的，试一下它的拷贝？

image-20221112103233500

那么，怎么去解决这个问题呢？

所以，接下来，我们来介绍几种C++标准库里的智能指针，来探究如何解决此问题

🌠3. 常见智能指针

📖3.1 auto_ptr

C++98版本的库中就提供了auto_ptr智能指针，它解决了拷贝赋值的问题，但也还有一些不足

auto_ptr实现原理：管理权转移的思想，下面将简化的模拟实现auto_ptr，主要体现它的思想：

namespace myPtr
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr = nullptr)
			: _ptr(ptr)
		{}

		~auto_ptr()
		{
			if (_ptr)
			{
				cout << "delete " << _ptr << endl;

				delete _ptr;
				_ptr = nullptr;
			}
		}

		auto_ptr(auto_ptr<T>& sp)
			: _ptr(sp._ptr)
		{
			sp._ptr = nullptr;
		}

		auto_ptr<T>& operator=(auto_ptr<T>& ap)
		{
			if (this != &ap)
			{
				//释放当前对象管理的资源
				if (_ptr)
					delete _ptr;

				//管理权转移
				_ptr = ap._ptr;
				ap._ptr = nullptr;
			}
            
            return *this;
		}

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

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

从它的拷贝构造和赋值重载可以看出，它以资源管理权转移的方式解决拷贝的问题.

但是，这样也带来另一个问题：

int main()
{
	myPtr::auto_ptr<int> p1(new int);
	myPtr::auto_ptr<int> p2 = p1;

	//*p1 = 10;  p1已经没有对资源的管理权，不能再使用！

	return 0;
}

由于p1的资源管理权已经转移给了p2，那它自己就失去对资源的管理及使用权，造成p1悬空.

📖3.2 unique_ptr

unique_ptr是C++11才开始提供的一种智能指针，它相比于auto_ptr更靠谱.

unique的实现原理：简单粗暴的禁止拷贝

我们依然是模拟实现一个unique_ptr来理解它的原理：

template<class T>
class unique_ptr
{
    public:
    unique_ptr(T* ptr = nullptr)
        : _ptr(ptr)
        {}

    ~unique_ptr()
    {
        if (_ptr)
        {
            cout << "delete " << _ptr << endl;

            delete _ptr;
            _ptr = nullptr;
        }
    }

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

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

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

unique_ptr采用一种简单粗暴的方式来解决拷贝的问题：直接删除拷贝构造函数和赋值重载函数，禁止拷贝

📖3.3 shared_ptr

shared_ptr也是C++11开始提供的，它能够解决智能指针拷贝的问题，并且它不像unique_ptr那样直接禁止拷贝，它是支持拷贝的.

shared_ptr的原理：通过引用计数的方式来实现多个shared_ptr对象之间共享资源

  1. 在shared_ptr内部，给它所管理的资源维护了一份引用计数，用来记录该资源被几个对象共同管理（共享）
  2. 在对象被销毁时（调用析构函数），就说明自己不使用该资源了，对用的引用计数减1
  3. 如果引用计数减到0，就说明当前自己已经是最后一个使用该资源的对象，所以此时必须释放该资源
  4. 如果不是0.那就说明还有其他对象管理这份资源，此时只需将引用计数减减即可，不需要释放资源
template<class T>
class shared_ptr
{
    public:
    shared_ptr(T* ptr = nullptr)
        : _ptr(ptr)
        {
            //将引用计数初始化为1
        }
    
    ~shared_ptr()
    {
        if (_ptr)
        {
            cout << "delete " << _ptr << endl;

            delete _ptr;
            _ptr = nullptr;
        }
    }

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

    T* operator->() const
    {
        return _ptr;
    }
    private:
    T* _ptr;
    //维护一个引用计数
};

那么，这个引用计数，我们应该怎样去维护呢？

  1. 使用普通变量int _pCount

    显然不行，由于私有成员变量是两个对象独有的，假如我们有两个智能指针p1和p2，对p1的引用计数的–不会影响p2

  2. 定义一个静态成员变量static int _pCount

    看似，好像可以，但是试一下如下场景：

    template<class T>
class shared_ptr
{
    public:
        shared_ptr(T* ptr = nullptr)
            : _ptr(ptr)
        {
             //在构造函数中将引用计数初始化为1
             _pCount = 1;
        }

        ~shared_ptr()
        {
            if (--_pCount == 0 && _ptr)
            {
                cout << "delete " << _ptr << endl;

                delete _ptr;
                _ptr = nullptr;
            }
        }

        shared_ptr(const shared_ptr<T>& sp)
        {
            _ptr = sp._ptr;

            ++_pCount;
        }

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

        T* operator->() const
        {
            return _ptr;
        }
    private:
        T* _ptr;
        //维护一个引用计数
        static int _pCount;
};

template<class T>
int shared_ptr<T>::_pCount = 0;

    int main()
{
    //_pCount = 1
	myPtr::shared_ptr<int> p1(new int);
    //_pCount = 2;
	myPtr::shared_ptr<int> p2(p1);
	
    //这一步又重新将_pCount置为1，导致最终只释放的一次资源
	myPtr::shared_ptr<int> p3(new int);

	return 0;
}

  3. 定义一个指针成员变量int* _pCount

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

    void Release()
    {
        if (--(*_pCount) == 0 && _ptr)
        {
            cout << "delete " << _ptr << endl;

            delete _ptr;
            _ptr = nullptr;

            delete _pCount;
            _pCount = nullptr;
        }
    }

    ~shared_ptr()
    {
        Release();
    }

    shared_ptr(const shared_ptr<T>& sp)
    {
        _ptr = sp._ptr;

        _pCount = sp._pCount;
        ++(*_pCount);
    }

    shared_ptr<T>& operator=(const shared_ptr<T>& sp)
    {
        //防止自赋值
        if (_ptr != sp._ptr)
        {
            Release();

            _ptr = sp._ptr;

            _pCount = sp._pCount;
            ++(*_pCount);
        }

        return *this;
    }

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

    T* operator->() const
    {
        return _ptr;
    }
    private:
    T* _ptr;
    //维护一个引用计数
    int* _pCount;
};

    这就是我们最终模拟实现出的shared_ptr.

📖3.4 shared_ptr的循环引用问题

shared_ptr的循环引用问题：

struct ListNode
{
	ListNode(const int& val = int())
		: _next(nullptr)
		, _prev(nullptr)
		, _val(val)
	{}

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

	myPtr::shared_ptr<ListNode> _next;
	myPtr::shared_ptr<ListNode> _prev;

	int _val;
};

int main()
{
	myPtr::shared_ptr<ListNode> p1(new ListNode(1));
	myPtr::shared_ptr<ListNode> p2(new ListNode(2));

	p1->_next = p2;
	p2->_prev = p1;

	return 0;
}

在上面的代码中，我们应该是有两份ListNode节点需要释放，运行程序：

image-20221112164835524

没有任何节点被释放.

image-20221112165831225

这便是shared_ptr的循环引用问题.

解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以

📖3.5 weak_ptr

weak_ptr原理：

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

//weak_ptr的_next和_prev不会增加node1和node2的引用计数

weak_ptr模拟实现

template<class T>
class weak_ptr
{
    public:
    weak_ptr()
    {}

    weak_ptr(const shared_ptr<T>& sp)
    {
        _ptr = sp._ptr;
    }

    weak_ptr<T>& operator=(const shared_ptr<T>& sp)
    {
        if (_ptr != sp.get())
        {
            _ptr = sp.get();
        }

        return *this;
    }

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

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

🌌4. 定制删除器

在我们写的智能指针的析构函数中，统一都使用delete来释放资源，但是，如果资源不是用new申请出来的呢？比如：new T[]，malloc，所以我们就需要定制删除器来规范释放资源的方式.

我们使用shared_ptr来做演示：

template<class T>
struct default_delete
{
    void operator()(T* ptr)
    {
        delete ptr;
    }
};

template<class T, class Del = default_delete<T>>
class shared_ptr
{
    public:
    shared_ptr(T* ptr = nullptr)
        : _ptr(ptr)
            , _pCount(new int(1))
        {}

    void Release()
    {
        if (--(*_pCount) == 0 && _ptr)
        {
            cout << "delete " << _ptr << endl;

            Del del;
            del(_ptr);
            _ptr = nullptr;

            delete _pCount;
            _pCount = nullptr;
        }
    }

    ~shared_ptr()
    {
        Release();
    }

    shared_ptr(const shared_ptr<T>& sp)
    {
        _ptr = sp._ptr;

        _pCount = sp._pCount;
        ++(*_pCount);
    }

    shared_ptr<T>& operator=(const shared_ptr<T>& sp)
    {
        //防止自赋值
        if (_ptr != sp._ptr)
        {
            Release();

            _ptr = sp._ptr;

            _pCount = sp._pCount;
            ++(*_pCount);
        }

        return *this;
    }

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

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

    T* get() const
    {
        return _ptr;
    }
    private:
    T* _ptr;
    //维护一个引用计数
    int* _pCount;
};

//定制new T[]类型的删除器
template<class T>
struct DeleteArray
{
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
};

int main()
{
	myPtr::shared_ptr<int, DeleteArray<int>> p(new int[10]);

	return 0;
}

⛺5. C++11和boost智能指针的关系

  1. C++98中产生了第一个智能指针auto_ptr
  2. C++ boost库给出了更实用的scoped_ptr和shared_ptr以及weak_ptr
  3. C++ TR1，引入了shared_ptr等，不过需要注意的是TR1并不是标准版
  4. C++ 11，引入了unique_ptr和shared_ptr以及weak_ptr，需要注意的是unique_ptr对应的boost的scoped_ptr，并且这些智能指针的实现原理是参考了boost库中的.
沉默.@
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
【C++11】智能指针
weixin_60478154的博客
04-02 7307
【C++11】智能指针
C++11智能指针
GG_Bruse的博客
03-21 654
使用智能指针是解决内存泄露问题的良好手段执行上述代码时，若用户输入的除数为0，那么Div()函数中就会抛出异常，这时程序的执行流会直接跳转到主函数中的catch块中执行，最终导致func()函数中申请的内存资源没有得到释放利用异常的重新捕获解决对于这种情况，可以在func()函数中先对Div()函数中抛出的异常进行捕获，捕获后先将之前申请的内存资源释放，然后再将异常重新抛出但这种方式并完全不可靠，有时可能会疏忽一些异常情况利用智能指针解决代码中将申请到的内存空间交给了一个SmartPtr对象进行管理。
C++11 智能指针
lyzzs222的博客
12-07 742
C++11 中智能指针 ，细节哈，其中原理以及模拟实现
C++11中的智能指针
weixin_53260189的博客
04-17 349
在C++中，有三种智能指针，分别是：unique_ptr、shared_ptr和weak_ptr。这三种智能指针都是在STL的头文件< memory> 中定义的，可以在C++11及其以上版本中使用。总之，选择何种智能指针取决于具体场景。如果需要拥有对象的独占权，那么应该选择unique_ptr；如果需要共享对象所有权，那么应该选择shared_ptr；如果需要打破shared_ptr循环引用，那么应该选择weak_ptr。
C++11：智能指针
crossoverpptx的博客
09-27 457
在C++中没有垃圾回收机制，必须自己释放分配的内存，否则就会造成内存泄露。解决这个问题最有效的方法是使用智能指针（smart pointer）。智能指针是存储指向动态分配（堆）对象指针的类，用于生存期的控制，能够确保在离开指针所在作用域时，自动地销毁动态分配的对象，防止内存泄露。随着C++的发展，有三个解决方案，一个方案对应着一种智能指针。其实，C++一共提供了四种智能指针：auto_ptr， unique_ptr，shared_ptr，weak_ptr。
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
C++智能指针详解abc
最新发布
08-24
C++智能指针详解 标题解释 "C++智能指针详解abc"这一标题表明，本文将详细介绍C++中的智能指针机制，包括其概述、原理、使用方法和结论等方面。 描述解释 "C++智能指针详解abc"这一描述表明，本文将对C++中的智能...
C++智能指针实例详解
09-04
主要介绍了C++智能指针实例详解,需要的朋友可以参考下
C++11智能指针之weak_ptr详解
01-19
【C++11新特性】 C++11智能指针之shared_ptr 1、为什么需要weak_ptr？ 在正式介绍weak_ptr之前，我们先来回忆一下shared_ptr的一些知识。 我们知道shared_ptr是采用引用计数的智能指针，多个shared_ptr实例可以指向...
C++11智能指针的基本原理及使用
周小哥的博客
08-03 145
智能指针是一个类，用来存储指向动态分配对象的指针，负责自动释放动态分配的对象，防止堆内存泄漏。动态分配的资源，交给一个类对象去管理，当类对象声明周期结束时，自动调用析构函数释放资源。
C++11 shared_ptr智能指针
Michael Tian的博客
05-29 350
C++11 shared_ptr智能指针 在实际的 C++ 开发中，我们经常会遇到诸如程序运行中突然崩溃、程序运行所用内存越来越多最终不得不重启等问题，这些问题往往都是内存资源管理不当造成的。比如： 有些内存资源已经被释放，但指向它的指针并没有改变指向（成为了野指针），并且后续还在使用； 有些内存资源已经被释放，后期又试图再释放一次（重复释放同一块内存会导致程序运行崩溃）； 没有及时释放不再使用的内存资源，造成内存泄漏，程序占用的内存资源越来越多。 针对以上这些情况，很多程序员认为 C++ 语言应该提供
【C++智能指针】智能指针的发展和循环引用的原理和解决
m0_72964546的博客
12-04 1202
RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源，在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。（就是把原本资源托管给一个类对象）
C++智能指针剖析
sayhello_world的博客
08-13 856
为什么要有？什么是智能指针？由于 C++ 语言没有自动内存回收机制，程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete，流程太复杂，最终导致没有 delete，异常导致程序过早退出，没有执行 delete 的情况并不罕见。为了方便内存回收，便有了智能指针。常见的智能指针0.汇总对于编译器来说，智能指针实际上是一个栈对象，并非指针类型，在栈对象生命期即将结束时，智能指针通过
c++11新特性——智能指针详解
weixin_46935110的博客
07-24 1405
c++11新特性——智能指针详解
C++智能指针作为成员变量
大隐隐于野
03-19 1156
class Device { }; class Settings { Device *device; public: Settings(Device *device) { this->device = device; } Device *getDevice() { return...
C++ 类的静态成员变量指针如何释放
热门推荐
qq_30722721的博客
08-16 1万+
类的静态成员变量指针，如何释放？ 目前有两种方法： 智能指针 使用静态变量维护一个引用计数，每创建一个对象，引用计数加1，析构函数中，引用计数减一，直到为0才释放内存 //方法一：使用智能指针 //使用智能指针在程序结束时（main大括号之外）会弹出结束对话框，使用普通指针不会弹出 #include <iostream> #include <memory> #inc...
C++11-智能指针和空指针
可可西里
03-29 7029
智能指针 如果指针ps有一个析构函数，该析构函数将在ps过期时释放它指向的内存。因此，问题在于它只是一个常规指针，不是有析构函数的类对象。如果它是对象，则可以在对象过期时，让它的析构函数删除指向的内存。   头文件memory std::shared_ptr ps(newstring); std::shared_ptr ps(newstring("a")); 所有的智能指针类都有一个e

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

沉默.@

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

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

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

打赏作者

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

抵扣说明：

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

余额充值