【C++从0到1】第二十三篇：智能指针

最新推荐文章于 2024-07-23 01:12:24 发布
最新推荐文章于 2024-07-23 01:12:24 发布
阅读量412 收藏 4
点赞数 9
分类专栏： C++ 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52809807/article/details/125565207
版权

文章目录

一、为什么需要智能指针？

下面我们先分析一下下面这段程序有没有什么内存方面的问题？

#include <iostream>
using namespace std;

int div()
{
	int x = 0;
	int y = 0;
	cin >> x >> y;
	if (y == 0)
		throw invalid_argument("除零错误");
	return x / y;
}

void fun()
{
	int* p1 = new int;
	int* p2 = new int;
	int* p3 = new int;

	//div()抛异常会导致p1, p2, p3没有释放资源
	cout << div() << endl;

	delete p1;
	delete p2;
	delete p3;
}

int main()
{
	try
	{
		fun();
	}

	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

二、内存泄漏

2.1 什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不=是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死

2.2 内存泄漏分类（了解）

C/C++程序中一般我们关心两种方面的内存泄漏

  • 堆内存泄漏(Heap leak)
    堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
  • 系统资源泄漏
    指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
  1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
  2. 采用RAII思想或者智能指针来管理资源。
  3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
  4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

总结一下:
内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具

2.3 如何避免内存泄漏

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

3.1 RAII

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

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

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效。
#include <iostream>
using namespace std;

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

	~SmartPtr()
	{
		delete _ptr;
	}
	//指针可以解引用，也可以通过->去访问所指空间中的内容，
	//因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用

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

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

private:
	T* _ptr;
};

int div()
{
	int x = 0;
	int y = 0;
	cin >> x >> y;
	if (y == 0)
		throw invalid_argument("除零错误");
	return x / y;
}

void fun()
{
	SmartPtr<int> sp1(new int);
	SmartPtr<int> sp2(new int);
	SmartPtr<int> sp3(new int);

	cout << div() << endl;
}

int main()
{
	try
	{
		fun();
	}

	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

总结一下智能指针的原理

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

3.2 std::auto_ptr

但是上面设计的智能指针会存在一些问题
在这里插入图片描述
C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题
在这里插入图片描述

在这里插入图片描述
模拟实现auto_ptr


#include <iostream>
using namespace std;

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

		~auto_ptr()
		{
			delete _ptr;
		}

		auto_ptr(auto_ptr& p)
		{
			_ptr = p._ptr;
			p._ptr = nullptr;
		}

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

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

	private:
		T* _ptr;
	};
}
int main()
{
	ts::auto_ptr<int> p1(new int);
	ts::auto_ptr<int> p2(p1);
	return 0;
}

在这里插入图片描述

3.4 std::unique_ptr

C++11中开始提供更靠谱的unique_ptr
在这里插入图片描述

在这里插入图片描述
模拟实现unique_ptr

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

namespace ts
{
	template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}

		~unique_ptr()
		{
			delete _ptr;
		}

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

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

		unique_ptr(const unique_ptr& p) = delete;
		unique_ptr<T>& operator=(const unique_ptr& p) = delete; 
	private:
		T* _ptr;
	};
}

但是需要拷贝的场景怎么办？

3.5 std::shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr
在这里插入图片描述

在这里插入图片描述
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源

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

模拟实现shared_ptr


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

namespace ts
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr)
			:_ptr(ptr)
			, _pRefCount(new int(1))
		{}

		shared_ptr(const shared_ptr& sp)
		{
			_ptr = sp._ptr;
			_pRefCount = sp._pRefCount;
			AddRef();
		}

		//释放资源
		void Release()
		{
			if (--(*_pRefCount) == 0 && _ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
				delete _pRefCount;
				_ptr = nullptr;
				_pRefCount = nullptr;
			}
		}

		void AddRef()
		{
			++(*_pRefCount);
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				//引用计数减到0，释放资源
				Release();
				_ptr = sp._ptr;
				_pRefCount = sp._pRefCount;
				AddRef();
			}
			return *this;
		}

		T* get()
		{
			return _ptr;
		}

		int use_count()
		{
			return *_pRefCount;
		}

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

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

		~shared_ptr()
		{
			Release();
		}
	private:
		T* _ptr;
		int* _pRefCount;//计数
	};
}

struct Date
{
	int _year = 0;
	int _month = 0;
	int _day = 0;
};

void SharePtrFunc(ts::shared_ptr<Date>& sp, int n)
{
	for (int i = 0; i < n; ++i)
	{
		ts::shared_ptr<Date> copy(sp);
		
		sp->_year++;
		sp->_month++;
		sp->_day++;
	}
}

int main()
{
	ts::shared_ptr<Date> sp(new Date);
	thread t1(SharePtrFunc, ref(sp), 1000);
	thread t2(SharePtrFunc, ref(sp), 500);

	t1.join();
	t2.join();

	cout << sp->_year << " " << sp->_month << " " << sp->_day << endl;
	cout << sp.use_count() << endl;
}

std::shared_ptr的线程安全问题
通过下面的程序我们来测试shared_ptr的线程安全问题。需要注意的是shared_ptr的线程安全分为两方面

  1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或–，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数++、–是需要加锁的，也就是说引用计数的操作是线程安全的。
  2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。
    在这里插入图片描述
    可以通过加锁来控制引用计数的安全。
#include <iostream>
#include <memory>
#include <thread>
#include <mutex>
using namespace std;

namespace ts
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr)
			:_ptr(ptr)
			,_pRefCount(new int(1))
			,_pmtx(new mutex)
		{}

		shared_ptr(const shared_ptr& sp)
		{
			_ptr = sp._ptr;
			_pRefCount = sp._pRefCount;
			_pmtx = sp._pmtx;
			AddRef();
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				//引用计数减到0，释放资源
				Release();
				_ptr = sp._ptr;
				_pRefCount = sp._pRefCount;
				_pmtx = sp._pmtx;
				AddRef();
			}
			return *this;
		}

		//释放资源
		void Release()
		{
			_pmtx->lock();

			bool flag = false;
			if (--(*_pRefCount) == 0 && _ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
				delete _pRefCount;
				_ptr = nullptr;
				_pRefCount = nullptr;

				flag = true;
			}
			_pmtx->unlock();

			if (flag)
			{
				delete _pmtx;
			}

		}

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

		T* get() const 
		{
			return _ptr;
		}

		int use_count() const
		{
			return *_pRefCount;
		}

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

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

		~shared_ptr()
		{
			Release();
		}

	private:
		T* _ptr;
		int* _pRefCount;//计数
		mutex* _pmtx;
	};
}

std::shared_ptr的循环引用
在这里插入图片描述

循环引用分析：

  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的引用计数。
在这里插入图片描述
在这里插入图片描述
模拟实现weak_ptr

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

namespace ts
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr)
			:_ptr(ptr)
			, _pRefCount(new int(1))
			, _pmtx(new mutex)
		{}

		shared_ptr(const shared_ptr& sp)
		{
			_ptr = sp._ptr;
			_pRefCount = sp._pRefCount;
			_pmtx = sp._pmtx;
			AddRef();
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				//引用计数减到0，释放资源
				Release();
				_ptr = sp._ptr;
				_pRefCount = sp._pRefCount;
				_pmtx = sp._pmtx;
				AddRef();
			}
			return *this;
		}

		//释放资源
		void Release()
		{
			_pmtx->lock();

			bool flag = false;
			if (--(*_pRefCount) == 0 && _ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
				delete _pRefCount;
				_ptr = nullptr;
				_pRefCount = nullptr;

				flag = true;
			}
			_pmtx->unlock();

			if (flag)
			{
				delete _pmtx;
			}

		}

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

		T* get() const
		{
			return _ptr;
		}

		int use_count() const
		{
			return *_pRefCount;
		}

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

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

		~shared_ptr()
		{
			Release();
		}

	private:
		T* _ptr;
		int* _pRefCount;//计数
		mutex* _pmtx;
	};

	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*() const
		{
			return *_ptr;
		}

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

	private:
		T* _ptr;
	};
}

3.6 定制删除器

在这里插入图片描述
在这里插入图片描述

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

class A
{
public:
	A()
		:_a(0)
	{}

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

private:
	int _a;
};

template<class T>
struct DeleteArray
{
	void operator()(const T* ptr)
	{
		delete[] ptr;
	}
};

// 默认情况，智能指针底层都是delete资源
// 如果资源不是new出来的，new[]，malloc， fopen
// 定制删除器：可调用对象
int main()
{
	unique_ptr<A, DeleteArray<A>> p1(new A[10]);
	return 0;
}

在这里插入图片描述
简单改造unique_ptr

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

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

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

		~unique_ptr()
		{
			D d;
			d(_ptr);
		}

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

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

		unique_ptr(const unique_ptr& p) = delete;
	private:
		T* _ptr;
	};
}

class A
{
public:
	A()
		:_a(0)
	{}

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

private:
	int _a;
};

template<class T>
struct DeleteArray
{
	void operator()(const T* ptr)
	{
		delete[] ptr;
	}
};

// 默认情况，智能指针底层都是delete资源
// 如果资源不是new出来的，new[]，malloc， fopen
// 定制删除器：可调用对象
int main()
{
	ts::unique_ptr<A, DeleteArray<A>> p1(new A[10]);
	ts::unique_ptr<A> p2(new A);
	return 0;
}

在这里插入图片描述

四、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中的实现的
小唐学渣
关注
专栏目录
【C++从入门到精通】第0篇：编程语言和C/C++
SHUTIAN2010的博客
09-05 395
本篇是《C++从入门到精通》的先导篇，介绍了本教程的初衷、C++来历，演示了C++编译器的安装。
【BOOST C++指针专题03】共享指针boost::shared_ptr
gongdiwudu的专栏
09-27 5297
boost::shared_ptr是另一个智能指针，与 boost::scoped_ptr有很大不同，本文阐述这种区别。
【学习点滴】c++智能指针（手写一个），及线程安全性
o小菜的博客
03-24 1670
目录 原始指针的问题 智能指针 问题：share_ptr是线程安全的吗？其底层实现是怎么样的？ 手撸一个简单的智能指针 原始指针的问题 使用 C++的指针可以动态开辟存储空间，但若在使用完毕后忘记释放（或在释放之前，程序 throw 出错误，导致没有释放），导致该内存单元一直被占据直到程序结束，即发生了所谓的内存泄漏。使用普通指针，容易造成堆内存泄露（忘记释放），二次释放，程序发生异常...
C++智能指针
fjhugjkdsd的博客
09-10 296
智能指针的作用是管理一个指针，因为存在以下这种情况:申请的空间在函数结束时忘记释放，造成内存泄漏。使用智能指针可以很大程度上的避免这个问题，因为智能指针就是一个类，当超出了类的作用域是，类会自动调用析构函数，析构函数会自动释放资源。所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放内存空间。
C++ 智能指针线程安全的问题
年年年的博客
11-05 7893
1. 线程安全的定义 多线程操作一个共享数据的时候，保证所有线程的行为是符合预期的则称为线程安全。 2. 智能指针的线程安全 2.1 智能指针的线程安全隐患（shared_ptr） 主要是以下几个方面： (1) 引用计数的加减操作是否线程安全。 (2) 修改shared_ptr指向是否线程安全。 (3) shared_ptr<T>的T的并发操作的安全性，也应该被讨论。 2.2 引用计数的讨论 shared_ptr中除了有一个指针，指向所管理数据的地址。还有一个指针执行一个控制块的地址，里面存放了
【C++】智能指针
fight_p的博客
03-02 2712
为什么需要智能指针呢？有了智能指针带来了什么问题？库里是如何解决的？就不得不说智能指针发展的历史。auto_ptr的解决方法、unique_ptr解决方法、shared_ptr解决方法。shared_ptr线程安全问题、循环引用问题。还有定制删除器。
C++智能指针的原理及其线程安全性不可多说
最新发布
秃头的博客
07-23 965
C++标准库中主要提供了三种智能指针：std::unique_ptr、std::shared_ptr和std::weak_ptr。原理： std::shared_ptr 是一种共享所有权的智能指针，多个shared_ptr可以指向同一个对象，使用引用计数来跟踪有多少个shared_ptr指向同一个对象。转移所有权的线程安全：**std::unique_ptr的所有权转移操作（例如std::move）在单线程环境中是安全的，但在多线程环境中需要额外的同步来保证线程安全。1.所有权独占：不能复制，但可以移动。
C++学习之第十三天-智能指针
weixin_49278191的博客
11-12 731
知识点总结： 1.引出: 如何智能指针自动关闭文件指针-代码实现 2.通用智能指针进行资源管理RAII-重载解引用运算符*和 -> 运算符,用于托管new出来的对象的释放。---代码实现 3.C++四种智能指针：auto_ptr, unique_ptr, shared_ptr,weak_ptr. 1.auto_ptr有bug,已被弃用 2.unique_ptr-不会让多个对象拥有同一资源，不允许进行拷贝构造、赋值，支持移动语义 3.share...
智能指针
季风的博客
02-05 534
一、简介 动态内存：除了静态内存和栈内存，每个程序还拥有一个内存池。这部分内存被称作自由空间（free store）或堆（heap）。程序用堆来存储动态分配（dynamicallyallocate）的对象——即那些在程序运行时分配的对象。动态对象的生存期由程序来控制，也就是说，当动态对象不再使用时，我们的代码必须显式地销毁它们。 虽然使用动态内存有时是必要的，但正确地管理动态内存是非常棘手的。 **智能指针存在的原因：**动态内存的使用很容易出问题，因为确保在正确的时间释放内存是极其困难的。有时我们会忘记释
2020.11.23 第13课 C++智能指针
LZGaile的博客
11-27 124
2020.11.23 第13课 C++智能指针 01_auto_ptr与unique_ptr -------------------------------- 智能指针 4个模板类 1.auto_ptr C++11放弃 2.unique_ptr 3.shared_ptr 4.weak_ptr -------------------------------- #include <iostream> #include <string> using namespace s
C++线程安全的智能指针
Muzzik的博客
05-04 860
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++ 智能指针
努力学习C/C++
06-17 1121
借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：不需要显式地释放资源。采用这种方式，对象所需的资源在其生命期内始终保持有效这里和互斥锁那里是一样的。
C++指针基础教程：深入理解及应用
知识点十：智能指针 智能指针是C++11引入的一个特性，它提供了一种自动管理内存的方式，减少内存泄漏的风险。智能指针有多种类型，如std::unique_ptr，std::shared_ptr和std::weak_ptr。智能指针在离开其作用域时，...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小唐学渣

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

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

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

打赏作者

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

抵扣说明：

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

余额充值