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

于 2023-06-01 18:58:14 发布
阅读量998 收藏 8
点赞数 4
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_58325487/article/details/130994139
版权

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

文章目录

1.为什么需要智能指针

C++11引入智能指针的主要原因是为了避免程序员手动管理动态内存分配和释放时可能出现的内存泄漏和悬空指针问题。在C++中，手动管理内存需要调用new和delete操作符，但是这种方式容易出错，特别是在多线程环境下使用。

智能指针可以自动管理动态内存的生命周期，并保证在不再需要这段内存时，自动释放它，从而避免了悬空指针和内存泄漏。

C++11引入了两种类型的智能指针：std::shared_ptr和std::unique_ptr。std::shared_ptr实现了共享所有权，可以被多个指针共享。std::unique_ptr则实现了“独占所有权”，只有一个指针可以拥有它的所有权。

使用智能指针可以:

  1. 在函数结束时自动释放内存空间，避免了手动释放内存空间。
  2. 简化代码，提高代码的可读性和健壮性，同时也可以减少程序员的工作量和出错的机会。

2. C++中智能指针和指针的区别是什么？

  1. 智能指针

    如果在程序中使用new从堆分配内存，等到不需要的时候，应使用delete将其释放。C++引入了智能指针以帮助自动完成这个过程。随后的编程体验(尤其是使用STL)表明，需要有更精致的机制。基于程序员的编程体验和BOOST库提供的解决方案，C++11摒弃了auto_ptr,并新增了三种智能指针：sunique_ptr,shared_ptr和weak_ptr。所有新增的智能指针都能与STL容器和移动语义协同工作。

  2. 指针

    C 语言规定所有变量在使用前必须先定义，指定其类型，并按此分配内存单元。指针变量不同于 整型变量和其他类型的变量，它是专门用来存放地址的，所以必须将它定义为“指针类型”。

  3. 智能指针和普通指针的区别

    智能指针和普通指针的区别在于智能指针实际上是对普通指针加了一层封装机制，区别是它负责自动 释放所指的对象，这样的一层封装机制的目的是为了使得智能指针可以方便的管理一个对象的生命期。

3. C++中的智能指针有哪些？分别解决的问题以及区别？

C++中的智能指针有4种，分别为：shared_ptr、unique_ptr、weak_ptr、auto_ptr，其中

auto_ptr被C++11弃用。

（1）auto_ptr（C++98的方案，C++11已经弃用）

https://cplusplus.com/reference/memory/auto_ptr/

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

#pragma once

namespace lxy
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr):_ptr(ptr){}
		auto_ptr(auto_ptr<T>& sp)
			:_ptr(sp._ptr)
		{
			//管理权转移
			sp._ptr = nullptr;
		}
		auto_ptr<T>& operator=(auto_ptr<T>& sp) 
		{
			if(this != &sp)
			{
				if (_ptr)	delete _ptr;
				//转移sp中的资源到当前对象中
				_ptr = sp._ptr;
				sp._ptr = nullptr;
			}
			return *this;
		}
		~auto_ptr()
		{
			if(_ptr)
			{
				std::cout << "delete:" << _ptr << std::endl;
				delete _ptr;
			}
		}

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

此时不会报错，sp2剥夺了sp1的所有权，但是当程序运行时访问sp1将会报错。所以auto_ptr的缺点是：存在潜在的内存崩溃问题。

（2）unique_ptr（替换auto_ptr）

http://www.cplusplus.com/reference/memory/unique_ptr/

unique_ptr实现独占式拥有或严格拥有概念，保证同一时间内只有一个智能指针可以指向该对象。它对于避免资源泄露，例如，以new创建对象后因为发生异常而忘记调用delete时的情形特别 有用。

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

#pragma once

namespace lxy
{
	template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}
		~unique_ptr() 
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}
		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		unique_ptr(const unique_ptr<T>& sp) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;

	private:
		T* _ptr;
	};
}

（3）shared_ptr

https://cplusplus.com/reference/memory/shared_ptr/

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

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

  1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共 享。

  2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减 一。

  3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；

  4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对 象就成野指针了。

shared_ptr 是为了解决 auto_ptr 在对象所有权上的局限性(auto_ptr 是独占的), 在使用引用计 数的机制上提供了可以共享所有权的智能指针。

#pragma once

namespace lxy
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			,_pRefCount(new int(1))
			,_pmtx(new mutex)
		{ }
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pRefCount(sp._pRefCount)
			, _pmtx(sp._pmtx)
		{
			AddRef();
		}

		void AddRef() 
		{
			_pmtx->lock();
			++(*_pRefCount);
			_pmtx->unlock();
		}

		void Release()
		{
			_pmtx->lock();
			bool flag = false;
			if (--(*_pRefCount) == 0 && _ptr)
			{
				std::cout << "delete:" << _ptr << std::endl;
				delete _ptr;
				delete _pRefCount;
				flag = true;
			}
			_pmtx->unlock();
			if (flag == true)
			{
				delete _pmtx;
			}
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				Release();
				_ptr = sp._ptr;
				_pRefCount = sp._pRefCount;
				_pmtx = sp._pmtx;
				AddRef();
			}
			return *this;
		}

		int use_count() { return *_pRefCount; }

		~shared_ptr()
		{
			Release();
		}

		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		T* get() const
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pRefCount;
		mutex* _pmtx;
	};
}

（4）weak_ptr

weak_ptr 是一种不控制对象生命周期的智能指针, 它指向一个 shared_ptr 管理的对象。进行该对象的内存管理的是那个强引用的 shared_ptr。weak_ptr只是提供了对管理对象的一个访问手段。weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作， 它只可以从一个shared_ptr或另一个 weak_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少。weak_ptr是用来解决shared_ptr相互引用时的死锁问题，如果说两个shared_ptr相互引用，那么这两个指针的引用计数永远不可能下降为0,资源永远不会释放。它是对对象的一种弱引用，不会增加对象的引用计数，和shared_ptr之间可以相互转化，shared_ptr可以直接赋值给 它，它可以通过调用lock函数来获得shared_ptr。

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

		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp.get())
		{}

		weak_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			return *this;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};

4.weak_ptr如何解决shared_ptr的循环引用问题

为了解决循环引用导致的内存泄漏，引入了弱指针weak_ptr，weak_ptr的构造函数不会修改引用计数的值，从而不会对对象的内存进行管理，其类似一个普通指针，但是不会指向引用计数的共享内存， 但是可以检测到所管理的对象是否已经被释放，从而避免非法访问。

5. weak_ptr 能不能知道对象计数为0，为什么？

不能。

weak_ptr是一种不控制对象生命周期的智能指针，它指向一个shared_ptr管理的对象。进行该对象管理的是那个引用的shared_ptr。weak_ptr只是提供了对管理 对象的一个访问手段。weak_ptr设计的目的只是为了配合shared_ptr而引入的一种智能指针，配合shared_ptr工作，它只可以从一个shared_ptr或者另一个weak_ptr对象构造，它的构造和析构不会引起计数的增加或减少。

6.shared_ptr怎么知道跟他共享对象的指针释放掉了

多个shared_ptr对象可以同时托管一个指针，系统会维护一个托管计数。当无shared_ptr托管该指针 时，delete该指针。

7.说说shared_ptr线程安全性

多线程环境下，调用不同shared_ptr实例的成员函数是不需要额外的同步手段的，即使这些shared_ptr拥有的是同样的对象。但是如果多线程访问（有写操作）同一个shared_ptr，则需要 同步，否则就会有race condition 发生。也可以使用 shared_ptr overloads of atomic functions来防止race condition的发生。

多个线程同时读同一个shared_ptr对象是线程安全的，但是如果是多个线程对同一个shared_ptr对象进行读和写，则需要加锁。

多线程读写shared_ptr所指向的同一个对象，不管是相同的shared_ptr对象，还是不同的shared_ptr对象，也需要加锁保护。

8.说说智能指针有没有内存泄漏的情况

智能指针有内存泄露的情况发生。

  • 智能指针发生内存泄露的情况

当两个对象同时使用一个shared_ptr成员变量指向对方，会造成循环引用，使引用计数失效， 从而导致内存泄露。

  • 智能指针的内存泄漏如何解决？

为了解决循环引用导致的内存泄漏，引入了弱指针weak_ptr，weak_ptr的构造函数不会修改引用计数的值，从而不会对对象的内存进行管理，其类似一个普通指针，但是不会指向引用计数的共 享内存，但是可以检测到所管理的对象是否已经被释放，从而避免非法访问。

class Child;
class Parent {
private:
	std::shared_ptr<Child> ChildPtr;
public:
	void setChild(std::shared_ptr<Child> child) {
		this->ChildPtr = child;
	}
	void doSomething() {
		if (this->ChildPtr.use_count()) {
		}
	}
	~Parent() {}
};

class Child {
private:
	std::shared_ptr<Parent> ParentPtr;
public:
	void setPartent(std::shared_ptr<Parent> parent) {
		this->ParentPtr = parent;
	}
	void doSomething() {
		if (this->ParentPtr.use_count()) {
		}
	}
	~Child() {}
};

int main() 
{
	std::weak_ptr<Parent> wpp;
	std::weak_ptr<Child> wpc;
	{
		std::shared_ptr<Parent> p(new Parent);
		std::shared_ptr<Child> c(new Child);
		p->setChild(c);
		c->setPartent(p);
		wpp = p;
		wpc = c;
		std::cout << p.use_count() << std::endl;
		std::cout << c.use_count() << std::endl;
	}
	std::cout << wpp.use_count() << std::endl;
	std::cout << wpc.use_count() << std::endl;
	return 0;
}

/* 
 程序运行结果：
        2
        2
        1
        1
*/

上述代码中，parent有一个shared_ptr类型的成员指向孩子，而child也有一个shared_ptr类型的成 员指向父亲。然后在创建孩子和父亲对象时也使用了智能指针c和p，随后将c和p分别又赋值给child的 智能指针成员parent和parent的智能指针成员child。从而形成了一个循环引用。

9.shared_ptr循环引用问题

看看这段代码：

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

int main()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;

	node1->_next = node2;
	node2->_prev = node1;
	//连接之后use_count++ 了
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}
/*运行结果：
		1
		1
		2
		2
*/

循环引用分析：

  1. node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。

  2. node1的_next指向node2，node2的_prev指向node1，引用计数变成2。

  3. node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上 一个节点。

  4. 也就是说_next析构了，node2就释放了。

  5. 也就是说_prev析构了，node1就释放了。

  6. 但是next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。

在这里插入图片描述

解决方案：

在引用技术的场景下，把节点的prev和next改成weak_ptr就可以了。

原理：

node1-> next = node2;和node2->prev = node1;时weak_ptr的next和_prev不会增加node1和node2的引用计数。

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

10.如果不是new出来的对象如何通过智能指针管理呢？

其实shared_ptr设计了一个删除其来解决这个问题

class A {};

template<class T>
struct FreeFunc {
	void operator()(T* ptr)
	{
		cout << "free:" << ptr << endl;
		free(ptr);
	}
};

template<class T>
struct DeleteArrayFunc {
	void operator()(T* ptr)
	{
		cout << "delete[]" << ptr << endl;
		delete[] ptr;
	}
};

int main()
{
	FreeFunc<int> freeFunc;
	std::shared_ptr<int> sp1((int*)malloc(4), freeFunc);
	DeleteArrayFunc<int> deleteArrayFunc;
	std::shared_ptr<int> sp2((int*)malloc(4), deleteArrayFunc);
	std::shared_ptr<A> sp4(new A[10], [](A* p) {delete[] p; });
	std::shared_ptr<FILE> sp5(fopen("test.txt", "w"), [](FILE* p)
		{fclose(p); });
	return 0;
}

11.你知道Boost库中的智能指针吗

C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小白又菜

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

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

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

打赏作者

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

抵扣说明：

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

余额充值