【C++】—— 智能指针

最新推荐文章于 2024-07-23 01:12:24 发布
最新推荐文章于 2024-07-23 01:12:24 发布
阅读量322 收藏 1
点赞数 1
分类专栏： C++学习 文章标签： C++ 智能指针 线程安全 循环引用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenxiyuehh/article/details/89006823
版权

一、为什么需要智能指针

我们先来看一段代码

#include <iostream>
#include <vector>
#include <exception>
using namespace std;

void Test()
{
	int* tmp = (int*)malloc(sizeof(int)* 100);
	int* p = new int;
	
	vector<int> v1(1000000000, 10);
	vector<int> v2(10, 10);
	//v2[10] = 20;

		free(tmp);
		delete p;
}
int main()
{
	try
	{
		Test();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "未知错误" << endl;
	}
	return 0;
}

智能指针
问题分析：上面的问题分析出来我们发现有以下两个问题？
1.由于抛出异常之后的跳转， malloc和new出来的空间，没有进行释放，存在内存泄漏的问题。
2. 异常安全问题。如果在malloc和free之间如果存在抛异常，那么还是有内存泄漏。这种问题就叫异常安全，异常介绍可参见博客 C++ 异常

二、智能指针的使用及原理

2.1 RAII

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效。
//设计一个SmartPtr类
template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr = nullptr)
		:_ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
		cout << "~SmatrPtr()" << endl;
	}
private:
	T* _ptr;
};

void Test()
{
	int* tmp = (int*)malloc(sizeof(int)* 100);
	//将tmp指针委托给sp对象，让sp对象帮助tmp指针管理空间，直到tmp指针被销毁
	SmartPtr<int> sp(tmp);
	//vector<int> v(100000000, 10);
	string s = "程序出错";
	throw s;

	free(tmp);
}
int main()
{
	try
	{
		Test();
	}
	catch (string& s)
	{
		cout << s << endl;
	}
	catch (...)
	{
		cout << "未知错误" << endl;
	}
	return 0;
}

智能指针

  • 这里我们看到虽然在抛出异常后程序跳转至catch处，在抛出异常处后面的代码并未执行，但是由于将tmp的空间交给对象sp管理，在程序执行完之后，对象会自动调用析构函数清理资源，此时指针tmp的空间得到了正确的释放，这就是智能指针的用处。
  • 两种情况都会调用析构函数：
  • 1、程序正常走完，出了作用域，sp对象被销毁调用析构函数清理资源
  • 2、程序抛出异常，跳出作用域到catch处，此时出了作用域sp对象被销毁调用析构函数清理资源

2.2 智能指针的原理

  • 上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此： == AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用 ==。
template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr = nullptr)
		:_ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
		cout << "~SmatrPtr()" << endl;
	}

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

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

struct Date
{
	int _year;
	int _mouth;
	int _day;
};

int main()
{
	SmartPtr<int> sp1(new int);
	//sp1.operator*() = 10;
	*sp1 = 10;
	cout << *sp1 << endl;


	SmartPtr<Date> sp2(new Date);
	//sp2.operator->()->_year = 2019;
	sp2->_year = 2019;
	sp2->_mouth = 10;
	sp2->_day = 19;

	return 0;
}

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

  1. RAII特性，利用对象的生命周期来控制程序资源。
  2. 重载operator*和opertaor->，具有像指针一样的行为。

三、std::auto_ptr的使用和问题

  • C++98版本的库中就提供了auto_ptr的智能指针
  • auto_ptr 链接：http://www.cplusplus.com/reference/memory/auto_ptr/
  • auto_ptr的实现原理就是：管理权转移的思想，下面我们来看一下这个智能指针的问题
  • 模拟实现一份auto_ptr了解原理
    在这里插入图片描述
    举个栗子
// C++库中的智能指针都定义在memory这个头文件中
#include <memory>
class Date
{
public:
	Date() { cout << "Date()" << endl; }
	~Date(){ cout << "~Date()" << endl; }
	int _year;
	int _month;
	int _day;
};


int main()
{
	auto_ptr<Date> ap(new Date);
	auto_ptr<Date> copy(ap);
	
	ap->_year = 2019;
	return 0;
}

auto_ptr
模拟实现，请看代码：

// 1.C++98智能指针auto_ptr,管理权转移，设计缺陷，严禁使用
namespace CXY
{
	template<class T>
	class AutoPtr//模拟实现auto_ptr
	{
	public:
		AutoPtr(T* Ptr)
			:_Ptr(Ptr)
		{}
		~AutoPtr()
		{
			if (_Ptr)
			{
				cout << "deleteA:" << _Ptr << endl;
				delete _Ptr;
			}
		}

		// CXY::AutoPtr<int> copy(ap);拷贝构造
		AutoPtr(AutoPtr<T>& ap)
		{
			_Ptr = ap._Ptr;
			ap._Ptr = nullptr;
		}

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

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

四、 std::unique_ptr的使用和问题

#include <memory>

class Date
{
public:
	Date() { cout << "Date()" << endl; }
	~Date(){ cout << "~Date()" << endl; }
	int _year;
	int _month;
	int _day;
};

int main()
{
	unique_ptr<Date> up(new Date);

	// unique_ptr的设计思路非常的粗暴-防拷贝，也就是不让拷贝和赋值。
	unique_ptr<Date> copy(up);
	return 0;
}

模拟实现，请看代码：

// 2.C++11 unique_ptr 防拷贝，简单粗暴的设计，鼓励使用
namespace CXY
{
	template<class T>
	class UniquePtr
	{
	public:
		UniquePtr(T* ptr)
			:_Ptr(ptr)
		{}

		~UniquePtr()
		{
			cout << "deleteU:" << _Ptr << endl;
			delete _Ptr;
		}

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

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

	private:
		//C++98防拷贝方式，只声明不实现+声明为私有
		//必须声明为私有，这样类外也无法实现，才能防拷贝
		//只声明编译无错误，为了防止系统生成默认的拷贝构造函数
		UniquePtr(UniquePtr<int> const& up);
		UniquePtr<int>& operator=(UniquePtr<int> const& up);
		
		//C++11防拷贝方式，delete
		//UniquePtr(UniqurPtr<int> const&)up = delete;
		//UniquePtr<int>& operator=(UniquePtr<int> const& up) = delete;

		T* _Ptr;
	};
}

五、 std::shared_ptr的使用与问题

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

share_ptr
模拟实现shared_ptr,请看代码：

// 3.C++11 shared_ptr 引用计数，支持拷贝，鼓励使用
namespace CXY
{
	template <class T>
	class SharedPtr
	{
	public:
		SharedPtr(T* ptr)
			:_Ptr(ptr)
			, _pcount(new int(1))
			, _pmtx(new mutex)//处理线程安全问题，保证只有一个线程对pcount进行++
		{}
		~SharedPtr()
		{
			/*if (--(*_pcount) == 0)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
				delete _pcount;
			}*/
			Release();
		}

		//CXY::SharedPtr<int> copy(sp);
		SharedPtr(SharedPtr<int> const& sp)
			:_Ptr(sp._Ptr)
			, _pcount(sp._pcount)
			, _pmtx(sp._pmtx)
		{
			if (_Ptr)//若是一个空指针则不用计数
				AddRefcount();
		}

		//sp = sp1
		SharedPtr<int>& operator=(SharedPtr<int> const& sp)
		{//先检查sp是否是最后一个指向资源的对象，如果是先释放资源
			if (_Ptr != sp._Ptr)//如果不是相同的对象才进行赋值
			{
				Release();//释放原来的空间，指向新的空间

				_Ptr = sp._Ptr;
				_pcount = sp._pcount;
				_pmtx = sp._pmtx;

				AddRefcount();
			}

			return *this;
		}

		int AddRefcount()
		{
			//保证是原子操作
			_pmtx->lock();
			++(*_pcount);
			_pmtx->unlock();

			return *_pcount;
		}

		void Release()
		{
			bool deleteflag = false;
			//引用计数减一，如果减到0即是最后一个使用资源的对象，就释放资源
			if (--(*_pcount) == 0)
			{
				cout << "deleteS:" << _Ptr << endl;
				delete _Ptr;
				delete _pcount;
				deleteflag = true;
			}
			if (deleteflag == true)//如果是最后一个对象，也把锁资源释放
				delete _pmtx;
		}
		T& operator*()
		{
			return *_Ptr;
		}

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

		int use_count()
		{
			return *_pcount;
		}
	private:
		T* _Ptr;
		int* _pcount;
		mutex* _pmtx;
	};
}

std::shared_ptr的线程安全问题

需要注意的是shared_ptr的线程安全分为两方面：

  1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或–，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数++、–是需要加锁的，也就是说引用计数的操作是线程安全的。
  2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。
  3. 注意一点，不仅是双核CPU有线程安全问题，单核CPU也有线程安全问题，由于单核CPU线程在执行时会有时间片概念，一个线程在执行时若是时间片用完了会暂时休眠，让其他进程执行，等下一个时间片再执行，此时就会造成和双核CPU同样的线程安全问题。
void SharePtrFunc(SharedPtr<Date>& sp, size_t n)
{
	cout << sp.Get() << endl;
	for (size_t i = 0; i < n; ++i)
	{
		// 这里智能指针拷贝会++计数，智能指针析构会--计数，这里是线程安全的。
		//SharedPtr<Date> copy(sp);
		// 这里智能指针访问管理的资源，不是线程安全的。所以我们看看这些值两个线程++了2n次，但是最
		//终看到的结果，并一定是加了2n
			copy->_year++;
		copy->_month++;
		copy->_day++;
	}
}
int main()
{
	SharedPtr<Date> p(new Date);
	cout << p.Get() << endl;

	const size_t n = 100;
	thread t1(SharePtrFunc, p, n);
	thread t2(SharePtrFunc, p, n);
	t1.join();
	t2.join();
	cout << p->_year << endl;
	cout << p->_month << endl;
	cout << p->_day << endl;
	return 0;
}

智能指针的循环引用问题

我们先来看一段代码了解一下什么是循环引用问题

#include <iostream>
#include <memory>
using namespace std;

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;
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}

循环引用

循环引用的解决方案weak_ptr

  • weak_ptr其实并不属于指针指针，它并不符合RAII的特性
  • 只有识别到循环引用的场景
  • 使用weak_ptr
// 解决方案：在引用计数的场景下，把节点中的_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; }
};
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;
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}

循环引用

CXYhh121
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 11 学习总结——智能指针
萧海的博客
08-03 387
智能指针 什么是智能指针？ 智能指针是借用RAII技术对普通指针进行封装，实质是一个对象，表现为一个指针，即智能的管理动态资源的释放；（重载操作符（->和*））； 对于编译器来说，智能指针实际上是一个栈对象，并非指针类型，在栈对象生命期即将结束时，智能指针通过析构函数释放有它管理的堆内存。 什么是RAII技术？ RAII技术即资源分配及初始化，使用类来封装资源的分配和初始化，再构造函数完成资源的分配和初始化，析构函数完成资源的清理，可以保证正确的初始化和资源释放。 智能指针的作用 del
【学习点滴】c++智能指针（手写一个），及线程安全性
o小菜的博客
03-24 1625
目录 原始指针的问题 智能指针 问题：share_ptr是线程安全的吗？其底层实现是怎么样的？ 手撸一个简单的智能指针 原始指针的问题 使用 C++的指针可以动态开辟存储空间，但若在使用完毕后忘记释放（或在释放之前，程序 throw 出错误，导致没有释放），导致该内存单元一直被占据直到程序结束，即发生了所谓的内存泄漏。使用普通指针，容易造成堆内存泄露（忘记释放），二次释放，程序发生异常...
C++智能指针
fjhugjkdsd的博客
09-10 279
智能指针的作用是管理一个指针，因为存在以下这种情况:申请的空间在函数结束时忘记释放，造成内存泄漏。使用智能指针可以很大程度上的避免这个问题，因为智能指针就是一个类，当超出了类的作用域是，类会自动调用析构函数，析构函数会自动释放资源。所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放内存空间。
C++线程安全的智能指针
Muzzik的博客
05-04 844
smart_ptr.hpp #pragma once #include <cstdint> #include <memory> template <class T> class smart_ptr { private: T* _obj; uint32_t _count; void add(); void dec(); protected: pub...
C++ 智能指针线程安全的问题
年年年的博客
11-05 7330
1. 线程安全的定义 多线程操作一个共享数据的时候，保证所有线程的行为是符合预期的则称为线程安全。 2. 智能指针的线程安全 2.1 智能指针的线程安全隐患（shared_ptr） 主要是以下几个方面： (1) 引用计数的加减操作是否线程安全。 (2) 修改shared_ptr指向是否线程安全。 (3) shared_ptr<T>的T的并发操作的安全性，也应该被讨论。 2.2 引用计数的讨论 shared_ptr中除了有一个指针，指向所管理数据的地址。还有一个指针执行一个控制块的地址，里面存放了
C++智能指针之auto_ptr、unique_ptr、shared_ptr、weak_ptr的详细介绍
一条二哈
03-27 1413
我们先来看看为什么需要有智能指针。看看下面的代码 void demo(std::string& str) { std::string *ps = new std::string(str); ... str = ps; return; } 上面的代码很明显的每次调用都在分配堆上的空间，但是却从不收回，从而导致内存泄露。当然我们知道在 return；前加上delete ps;。...
奇妙的C++——智能指针
03-18
在C++编程中，智能指针（Smart Pointer）是一种非常重要的概念，它为管理动态内存提供了更加安全和方便的方式。智能指针本质上是封装了原始指针的对象，它能够自动管理所指向的对象生命周期，防止内存泄漏。在C++11...
c++11 智能指针（csdn）————程序.pdf
12-01
C++11 智能指针详解 C++11 中引入了智能指针，用于自动管理堆内存，避免内存泄漏和二次释放。智能指针通过引用计数来管理堆内存，当最后一个指向对象的智能指针被销毁时，自动释放对象。C++11 中有四种智能指针：...
【C++11】三大神器之——智能指针
ZER00000001的博客
12-13 3315
在Cpp11新标准下学习C++三大神器之一的智能指针
C++11——智能指针
duxinyu的博客
06-28 247
智能指针 智能指针主要用于管理在堆上分配的内存，它的作用是管理一个指针，因为存在以下这种情况：申请的空间在函数结束时忘记释放，造成内存泄漏。使用智能指针可以很大程度上的避免这个问题，因为智能指针是一个类，当超出了类的实例对象的作用域时，会自动调用对象的析构函数，析构函数会自动释放资源。所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放内存空间。 C++11中的智能指针有三个： 1. unique_ptr 2. shared_ptr 3. weak_ptr unique_ptr
一个涉及智能指针，临界区，唯一实例，类模板和线程安全的类的编写例子
01-08
一个涉及智能指针，临界区，唯一实例，类模板和线程安全的类的编写例子， 可以直接调用使用。适合c c++ 初学者参考使用
三、c++11智能指针之shared_ptr代码实现：线程安全
Chiang11的博客
06-09 1156
这里我们将互斥锁定义为mutex 的指针类型。为什么不是静态变量类型：考虑到一个智能指针类会被创建出多个实例，比如智能指针对象p1和p2指向资源1，p3和p4指向资源2。如果定义为静态变量，一个线程访问p1会阻塞p3，但他们本身就指向不同对象，本来是互不影响的，因此互斥锁不能定义为静态变量。为什么不是 muex 类型。
对于一个指针可以多次使用delete_C++如何正确使用智能指针？
weixin_39828960的博客
12-05 485
C++11 中推出了三种智能指针，unique_ptr、shared_ptr 和 weak_ptr，同时也将 auto_ptr 置为废弃(deprecated)。但是在实际的使用过程中，很多人都会有这样的问题：不知道三种智能指针的具体使用场景无脑只使用 shared_ptr认为应该禁用 raw pointer(裸指针，即 Widget*这种形式)，全部使用智能指针本文试图理清楚三种智能指针的具体使...
C++11提供智能指针shared_ptr是不是线程安全的
xiaobai
08-10 4886
“Boost文档对于shared_ptr的线程安全有一段专门的记述，内容如下： shared_ptrobjectsofferthesamelevelofthreadsafetyasbuilt-intypes.Ashared_ptrinstancecanbe"read"(accessedusingonlyconstoperations)simult...
深入理解C++智能指针：分类、使用及多线程安全性
BXA
05-10 3731
在c++开发中指针是必不可少的。但是使用不当会引发一系列的bug，如常见的空指针释放，指针的重复释放，悬挂指针等等。这些错误会导致卡死程序，甚至会导致更严重的内存泄漏。C++ 的智能指针 shared_ptr 是对原始指针的一种封装。使用 shared_ptr 可以自动管理内存，避免了内存泄漏的问题。shared_ptr 是 C++11 标准引入的，位于头文件<memory>中。
C++智能指针的原理及其线程安全性不可多说
最新发布
秃头的博客
07-23 886
C++标准库中主要提供了三种智能指针：std::unique_ptr、std::shared_ptr和std::weak_ptr。原理： std::shared_ptr 是一种共享所有权的智能指针，多个shared_ptr可以指向同一个对象，使用引用计数来跟踪有多少个shared_ptr指向同一个对象。转移所有权的线程安全：**std::unique_ptr的所有权转移操作（例如std::move）在单线程环境中是安全的，但在多线程环境中需要额外的同步来保证线程安全。1.所有权独占：不能复制，但可以移动。
C++ 智能指针
m0_51364183的博客
03-14 95
话不多说上代码！ void div() { int* p = new int; int m = 0; int n = 0; cin >> m >> n; if (n == 0) { throw exception(); } cout << "continue" << endl; cout << m / n; delete p; } int main() { try { div(); } catch (exce
【C++】智能指针
qq_45967533的博客
07-07 655
本篇主要从智能指针存在的必要性入手，讲解了智能指针的原理和特性，以及智能指针的发展历史，并对常用的unique_ptr和shared_ptr进行了模拟实现，以及删除器相关的内容
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值