25.智能指针(auto_ptr的使用和模拟实现、shared_ptr的使用和模拟实现、unique_ptr的使用和模拟实现、weak_ptr的使用和模拟实现、智能指针的线程安全问题)

最新推荐文章于 2024-05-23 15:08:02 发布
最新推荐文章于 2024-05-23 15:08:02 发布
阅读量653 收藏 14
点赞数 18
分类专栏： c++ 文章标签： 安全 算法 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Q2691463021/article/details/138662100
版权

1. 为什么需要智能指针？

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

  • 场景一
// 如果p1和p2 new不会抛异常，仅仅只考虑div()会出现异常
int div()
{
	int a, b;
	cin >> a >> b;
    // 如果函数div()出现除0错误，则会抛异常
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
    // 1、如果p1这里new 抛异常会如何？
    // 如果是p1抛异常，那么就会直接跳转到main()函数对应的catch()中，此时并没有需要去释放的资源，因此是不需要处理的
	int* p1 = new int;
    
    // 2、如果p2这里new 抛异常会如何？
    // 此时p1的资源已经被申请了，如果说，此时p2抛异常，那么就会直接跳转到main()函数对应的catch()中，然而p1申请的资源并没有被释放，这样就会造成内存泄漏
	int* p2 = new int;
    // 如果div()会抛异常，那么throw后会直接跳转到main()函数，这样的话p1和p2就不会被释放，那样就会造成内存泄漏
	cout << div() << endl;
	delete p1;
	delete p2;
}

int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
    
	return 0;
}
  • 场景二
int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");

	return a / b;
}

void func()
{
    // p1抛异常，没有要释放的资源，所以不会造成内存泄漏
	int* p1 = new int[10];
    // p2初始化
	int* p2 = nullptr;
	try
	{
        // p2抛异常，因为p2被try块保护，所以跳转到下面的catch块里面，会先释放p1的资源，再处理异常
        // 因此不会造成内存泄漏，div() 同理
        // 这样的处理方式是正确的，但是代码会十分冗余
        // 如果还有p3、p4等等也要抛异常呢，这样就会变得十分冗余和复杂了
        // 因此才有了智能指针的提出，来解决这个问题
		p2 = new int[20];

		try
		{
			cout << div() << endl;
		}
		catch (...)
		{
			delete[] p1;
			delete[] p2;

			throw;
		}
	}
	catch (...)
	{
        delete[] p1;
		//...
	}

	delete[] p1;
	delete[] p2;
}

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

	return 0;
}

2.智能指针

2.1 RAII

  • **RAII（Resource Acquisition Is Initialization）**是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
  • ​ **在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。**借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：
    • 不需要显式地释放资源。
    • 采用这种方式，对象所需的资源在其生命期内始终保持
// 智能指针的类模板
template<class T>
class SmartPtr
{
public:
    // 构造函数
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

    // 析构函数
	~SmartPtr()
	{
		delete[] _ptr;
        cout << _ptr << endl;
	}
private:
	T* _ptr;
};

// 除法函数
int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");

	return a / b;
}
  • 使用智能指针

1、如果p1这里new 抛异常会如何？
2、如果p2这里new 抛异常会如何？
3、如果div()调用这里又会抛异常会如何？

void Func()
{
    // 如果是p1抛异常，那么就会直接跳转到main()函数对应的catch()中，此时并没有需要去释放的资源，因此是不需要处理的
	int* p1 = new int[10];
	SmartPtr<int> sp1(p1);

    // 如果是p2抛异常，那么就会直接跳转到main()函数对应的catch()中，此时p1申请的资源是需要进行释放的，但是此时p1的资源是归智能指针的对象sp1管理的，因次当抛异常跳转到main()之后，栈帧还是是正常销毁，当Func()的栈帧销毁，对象sp1就会调用p1的析构函数，将它的资源进行释放，因此p1申请的资源会被释放，并不会造成内存泄漏
	int* p2 = new int[20];
	SmartPtr<int> sp2(p2);

    // 当div()抛异常时，跳转到main(),Func()的栈帧销毁，sp1和sp2会调用p1和p2的析构函数，释放p1和p2管理的资源，并不会造成内存泄漏。
	cout << div() << endl;
     // 可以自己进行调试查看，以下是我调试的结果，p1和p2都被释放了
    // 1 0
	// 00B85EC0
	// 00B86058
	// 除0错误
}

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

	return 0;
}

2.2 像指针一样（Smartptr）

​ 上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：SmartPtr模板类中还得需要将* 和 ->重载下，才可让其像指针一样去使用。

  • 智能指针的类模板
template<class T>
 class SmartPtr
 {
 public:
    // 构造函数和析构函数，被称为RAII
    // 构造函数用来保存资源
	 SmartPtr(T* ptr)
		 :_ptr(ptr)
	 {}

    // 析构函数用来释放资源
	~SmartPtr()
	{
		delete[] _ptr;
		delete _ptr;
		cout << _ptr << endl;
	}

    // *，->，[]的重载被称为像指针一样，也就是像指针一样去使用
	T& operator*()
	{
		return *_ptr;
	}

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

	T& operator[](size_t pos)
	{
		return _ptr[pos];
	}
 private:
	 T* _ptr;
 };
  • 使用智能指针
int div()
{
    int a, b;
    cin >> a >> b;
    if (b == 0)
        throw invalid_argument("除0错误");

    return a / b;
}

void Func()
{
    // 此时可以通过智能指针(解引用，或者->)访问new的资源，而不需要通过p1/p2
    SmartPtr<int> sp1(new int[10]); 
    SmartPtr<int> sp2(new int[20]);

    *sp1 = 10;
    sp1[0]--;

    cout << *sp1 << endl;  // 打印结果为9
    cout << div() << endl; 
}

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

	return 0;
}

2.3 std::auto_ptr

  • C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。

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

  • 对于auto_ptr我们仅限于了解，拒绝使用它。

namespace  qwy
{
    // 智能指针的类模板
	template<class T>
	class auto_ptr
	{
	public:
		// RAII
		// 保存资源
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}

		// 释放资源
		~auto_ptr()
		{
			// delete[] _ptr;
			delete _ptr;
			cout << _ptr << endl;
		}

	 // 拷贝构造
     // ap2(ap1);
	 // 将ap1.ptr置空了
     // 此处不可以使用const修饰auto_ptr<T>& sp，否则_ptr(sp._ptr)初始化之后，_ptr的权限也会被缩小
		auto_ptr(auto_ptr<T>& sp)
			:_ptr(sp._ptr)
		{
            // 将原始的智能指针置空。因为一份资源，只能够由一个智能指针进行管理
			sp._ptr = nullptr;
		}

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

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

		T& operator[](size_t pos)
		{
			return _ptr[pos];
		}
	private:
		T* _ptr;
	};
}

int main()
{
	qwy::auto_ptr<int> ap1(new int);
	qwy::auto_ptr<int> ap2(ap1);// 拷贝之后，ap1变为了空指针

	(*ap2)++;
    
    // 根据auto_ptr的底层，此时ap1.ptr已经被置为空指针了，因此此处会报错
	(*ap1)++;

	return 0;
}

2.4 std::unique_ptr

​ 为了防止auto_ptr的问题，unique_ptr应运而生，其原理：简单粗暴 – >防拷贝（防止智能指针对象被拷贝）。

namespace  qwy
{
    // 智能智能指针的类模板
	template<class T>
	class unique_ptr
	{
	public:
		// RAII
		// 保存资源，构造函数
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}

		// 释放资源，析构函数
		~unique_ptr()
		{
			// delete[] _ptr;
			delete _ptr;
			cout << _ptr << endl;
		}

        // 防拷贝（禁用拷贝构造函数）
		unique_ptr(const unique_ptr<T>& up) = delete;
        
        // 防赋值 (禁用赋值重载函数)
		unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;

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

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

		T& operator[](size_t pos)
		{
			return _ptr[pos];
		}
	private:
		T* _ptr;
	};
}

int main()
{
    qwy::unique_ptr<int> up1(new int);
   
    // 此处会报错，因为unique_ptr类型的智能指针对象是禁止被拷贝的
	qwy::unique_ptr<int> up2(up1);   
    
    return 0;
}

2.5 std::shared_ptr

  • shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。
  1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
  2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
  3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
  4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
  • 智能指针的类模板
namespace qwy
{
    // 智能指针的类模板
    template<class T>
	class shared_ptr
	{
	public:
		// RAII
		// 保存资源
        // _pcount(new int(1))，在堆上面开一块空间来存放这个计数
        // 构造函数，将创建的int类型的变量初始化为1,表示现在只有一份资源
        // 将资源的指针初始化给_ptr
		shared_ptr(T* ptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

		// 析构函数
		~shared_ptr()
		{
			Release();
		}

        // 拷贝构造，也就是增加计数
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
		{
			++(*_pcount); // 计数++
		}

        // 释放一份资源，计数器--
		void Release()
		{
			if (--(*_pcount) == 0)
			{
				delete _pcount; 
				delete _ptr;
			}
		}

		// sp1 = sp1;  两侧为同一个对象
		// sp1 = sp2;  两侧间接为同一个对象（sp2是sp1拷贝的对象）
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
            // 如果两个智能指针管理的资源不相同
			if (_ptr != sp._ptr)
			{
                // sp1 = sp4
                // 将sp4赋值给sp1，那么为了防止赋值后，sp1的原有的资源无人管理，造成内存泄漏，那么首先需要将sp1进行释放，再进行赋值
                // sp1调用的Release()， this->Release()
				Release();
				_pcount = sp._pcount;
				_ptr = sp._ptr;
				++(*_pcount);
			}

            // *this就是赋值后得到的对象
			return *this;
		}

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

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

		T& operator[](size_t pos)
		{
			return _ptr[pos];
		}
        
	private:
		T* _ptr;
		int* _pcount;   // 计数器
	};
}
  • 使用智能指针
int main()
{
    qwy::shared_ptr<int> sp1(new int(0));
	qwy::shared_ptr<int> sp2(sp1);
	qwy::shared_ptr<int> sp3(sp2);
	(*sp1)++;
	(*sp2)++;

	cout << *sp1 << endl;
	cout << *sp2 << endl;
    // 打印结果为：
	// 2
	// 2
	sp1 = sp2;

	qwy::shared_ptr<int> sp4(new int(10));
	qwy::shared_ptr<int> sp5(sp4);
	sp1 = sp4;

	return 0;
}

3.Shared_Ptr的线程安全问题

SmartPtr.h

#pragma once
#pragma once

#include <thread>
#include <mutex>

// 1、RAII
// 2、像指针一样使用
// 3、拷贝问题
namespace qwy
{
    // 智能指针的类模板
	template<class T>
	class shared_ptr
	{
	public:
		// RAII
		// 保存资源
		// _pcount(new int(1))，在堆上面开一块空间来存放这个计数
		// 构造函数，将创建的int类型的变量初始化为1,表示现在只有一份资源
		// 将资源的指针初始化给_ptr
		shared_ptr(T* ptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

		// 析构函数
		~shared_ptr()
		{
			Release();
		}

		// 拷贝构造，也就是增加计数
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
		{
			++(*_pcount); // 计数++
		}

		// 释放一份资源，计数器--
		void Release()
		{
			if (--(*_pcount) == 0)
			{
				delete _pcount;
				delete _ptr;
			}
		}

		// sp1 = sp1;  两侧为同一个对象
		// sp1 = sp2;  两侧间接为同一个对象
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				// sp1 = sp4
				// 将sp4赋值给sp1，那么为了防止赋值后，sp1的原有的资源无人管理，造成内存泄漏，那么首先需要将sp1进行释放，再进行赋值
				// sp1调用的Release()， this->Release()
				Release();
				_pcount = sp._pcount;
				_ptr = sp._ptr;
				++(*_pcount);
			}

			// *this就是赋值后得到的对象
			return *this;
		}

		int use_count() const
		{
			return *_pcount;
		}

		T* get() const
		{
			return _ptr;
		}

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

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

		T& operator[](size_t pos)
		{
			return _ptr[pos];
		}

	private:
		T* _ptr;
		int* _pcount;   // 计数器
	};



	// shared_ptr 本身是线程安全的。（拷贝和析构时，引用计数++ --是线程安全的）
	// shared_ptr 管理资源的访问不是线程安全的，需要用的地方自行保护。
	void test_shared_ptr1()
	{
		int n = 10000;
		qwy::shared_ptr<int> sp1(new int(1));

		// 使用lambda表达式来构造这个线程
		thread t1([&]()
			{
				for (int i = 0; i < n; ++i)
				{
					qwy::shared_ptr<int> sp2(sp1);
				}
			});

		thread t2([&]()
			{
				for (int i = 0; i < n; ++i)
				{
					qwy::shared_ptr<int> sp3(sp1);
				}
			});

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

		cout << sp1.use_count() << endl;
		cout << sp1.get() << endl;
	}
	
}

main

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

#include "SmartPtr.h"

int main()
{

	qwy::test_shared_ptr1();

	return 0;
}

test_shared_ptr1()

// 情况1：
void test_shared_ptr1()
{
    int n = 10000;
    qwy::shared_ptr<int> sp1(new int(1));

    // 使用lambda表达式来构造这个线程
    thread t1([&]()
              {
                  for (int i = 0; i < n; ++i)
                  {
                      qwy::shared_ptr<int> sp2(sp1);
                  }
              });

    thread t2([&]()
              {
                  for (int i = 0; i < n; ++i)
                  {
                      qwy::shared_ptr<int> sp3(sp1);
                  }
              });

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

    cout << sp1.use_count() << endl;
    cout << sp1.get() << endl;
}
  • 打印结果

image-20230815140152638

  • 原因

image-20230815175109078

  • 注：线程1和线程2并行时，同时拿到引用计数，假设此时的引用计数是2，那么两个线程拿到的都是2，两个线程++后都会得到的引用计数都是3，写回到内存引用计数是3。（实际上此时的引用计数应该是4）

加锁（解决引用计数线程安全问题）

  • 用锁对拷贝构造、赋值拷贝、析构中的++或者–进行保护
  • 加锁保护之后，则不会再出现上面的线程安全问题
#pragma once

#include <thread>
#include <mutex>

// 1、RAII
// 2、像指针一样使用
// 3、拷贝问题
namespace qwy
{
	template<class T>
	class shared_ptr
	{
	public:
		// RAII
		// 保存资源
		// 构造函数
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
			, _pmtx(new mutex)      // 私有成员变量中，加了一个锁对象
		{}


		// 析构函数
		// 释放资源
		~shared_ptr()
		{
			Release();
		}

		// 拷贝构造
		// sp2(sp1)
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
			, _pmtx(sp._pmtx)
		{
			// 使用锁对++进行保护
			// 多个线程只能够串联执行
			_pmtx->lock(); 
			++(*_pcount);
			_pmtx->unlock();
		}

		void Release()
		{
			// 每个线程都有自己的独立栈结构，因此每个线程都有自己的flag，
			// 因此当flag为ture时，是没有线程安全问题的，此时将智能指针对象释放
			// 进程的堆空间，全局变量、静态变量是所有线程间共享的
			bool flag = false;

			_pmtx->lock();
			// *_pcount是堆上面的资源
			if (--(*_pcount) == 0)
			{
				delete _ptr;
				delete _pcount;

				// 当引用计数*_pcount为0时，此时我们不仅需要将_ptr和_pcount进行释放，
				// 还需要将锁进行释放，且必须是解锁之后，在释放锁，所以当*_pcount为0时
				// 将flag赋值为true，代表我们可以释放锁了
				flag = true;
			}
			_pmtx->unlock();

			if (flag == true)
			{
				delete _pmtx;
			}
		}

		// 赋值拷贝
		// sp1 = sp1;
		// sp1 = sp2;
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				Release();

				_pcount = sp._pcount;
				_ptr = sp._ptr;
				_pmtx = sp._pmtx;

				// 使用锁对++进行保护
				_pmtx->lock();
				++(*_pcount);
				_pmtx->unlock();
			}

			return *this;
		}

		int use_count() const
		{
            // 智能指针管理的资源的引用计数
			return *_pcount;
		}

		T* get() const
		{
			return _ptr;
		}

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

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

		T& operator[](size_t pos)
		{
			return _ptr[pos];
		}
	private:
		T* _ptr;
		int* _pcount;
		mutex* _pmtx;
	};

	// shared_ptr 本身是线程安全的。（拷贝和析构时，引用计数++ --是线程安全的）
	// shared_ptr 管理资源的访问不是线程安全的，需要用的地方自行保护。
	void test_shared_ptr1()
	{
		int n = 10000;
		qwy::shared_ptr<int> sp1(new int(1));

		thread t1([&]()
			{
				for (int i = 0; i < n; ++i)
				{
					qwy::shared_ptr<int> sp2(sp1);
				}
			});

		thread t2([&]()
			{
				for (int i = 0; i < n; ++i)
				{
					qwy::shared_ptr<int> sp3(sp1);
				}
			});

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

		cout << sp1.use_count() << endl;
		cout << sp1.get() << endl;
	}
	
}

加锁（解决智能指针资源线程安全问题）

#pragma once

#include <thread>
#include <mutex>

// 1、RAII
// 2、像指针一样使用
// 3、拷贝问题
namespace qwy
{
	template<class T>
	class shared_ptr
	{
	public:
		// RAII
		// 保存资源
		// 构造函数
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
			, _pmtx(new mutex)
		{}


		// 析构函数
		// 释放资源
		~shared_ptr()
		{
			Release();
		}

		// 拷贝构造
		// sp2(sp1)
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
			, _pmtx(sp._pmtx)
		{
			// 使用锁对++进行保护
			// 多个线程只能够串联执行
			_pmtx->lock(); 
			++(*_pcount);
			_pmtx->unlock();
		}

		void Release()
		{
			bool flag = false;

			_pmtx->lock();
			// *_pcount是堆上面的资源
			if (--(*_pcount) == 0)
			{
				delete _ptr;
				delete _pcount;

				// 当引用计数*_pcount为0时，此时我们不仅需要将_ptr和_pcount进行释放，
				// 还需要将锁进行释放，且必须是解锁之后，在释放锁，所以当*_pcount为0时
				// 将flag赋值为true，代表我们可以释放锁了
				flag = true;
			}
			_pmtx->unlock();

			if (flag == true)
			{
				delete _pmtx;
			}
		}

		// 赋值拷贝
		// sp1 = sp1;
		// sp1 = sp2;
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				Release();

				_pcount = sp._pcount;
				_ptr = sp._ptr;
				_pmtx = sp._pmtx;

				// 使用锁对++进行保护
				_pmtx->lock();
				++(*_pcount);
				_pmtx->unlock();
			}

			return *this;
		}

		int use_count() const
		{
			return *_pcount;
		}

		T* get() const
		{
			return _ptr;
		}

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

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

		T& operator[](size_t pos)
		{
			return _ptr[pos];
		}
	private:
		T* _ptr;
		int* _pcount;
		mutex* _pmtx;
	};

    // 日期类
	struct Date
	{
		int _year = 0;
		int _month = 0;
		int _day = 0;
	};

	// shared_ptr 本身是线程安全的。（拷贝和析构时，引用计数++ --是线程安全的）
	// shared_ptr 管理资源的访问不是线程安全的，需要用的地方自行保护。
	void test_shared_ptr1()
	{
		int n = 50000;
		qwy::shared_ptr<Date> sp1(new Date);

		thread t1([&]()
			{
				for (int i = 0; i < n; ++i)
				{
                    // 此处_year++，_day++，_month++有线程安全的问题
					qwy::shared_ptr<Date> sp2(sp1);
					sp2->_year++;
					sp2->_day++;
					sp2->_month++;
				}
			});

		thread t2([&]()
			{
				for (int i = 0; i < n; ++i)
				{
					qwy::shared_ptr<Date> sp3(sp1);
					sp3->_year++;
					sp3->_day++;
					sp3->_month++;
				}
			});

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

		cout << sp1.use_count() << endl;
		cout << sp1.get() << endl;

		cout << sp1->_year << endl;
		cout << sp1->_month << endl;
		cout << sp1->_day << endl;
	}
}
  • 打印结果

image-20230815184013108

  • 解决方法（加锁）
// shared_ptr 本身是线程安全的。（拷贝和析构时，引用计数++ --是线程安全的）
// shared_ptr 管理资源的访问不是线程安全的，需要用的地方自行保护。

void test_shared_ptr1()
{
    int n = 50000;
    mutex mtx;
    qwy::shared_ptr<Date> sp1(new Date);

    thread t1([&]()
              {
                  for (int i = 0; i < n; ++i)
                  {
                      // 访问智能指针的资源时，进行加锁，避免线程安全的问题
                      qwy::shared_ptr<Date> sp2(sp1);
                      mtx.lock();
                      sp2->_year++;
                      sp2->_day++;
                      sp2->_month++;
                      mtx.unlock();
                  }
              });

    thread t2([&]()
              {
                  for (int i = 0; i < n; ++i)
                  {
                      qwy::shared_ptr<Date> sp3(sp1);
                      mtx.lock();
                      sp3->_year++;
                      sp3->_day++;
                      sp3->_month++;
                      mtx.unlock();
                  }
              });

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

    cout << sp1.use_count() << endl;
    cout << sp1.get() << endl;

    cout << sp1->_year << endl;
    cout << sp1->_month << endl;
    cout << sp1->_day << endl;
}

循环引用（shared_ptr的缺点）

#pragma once

#include <thread>
#include <mutex>

// 1、RAII
// 2、像指针一样使用
// 3、拷贝问题
namespace qwy
{
    // 智能指针的类模板
	template<class T>
	class shared_ptr
	{
	public:
		// RAII
		// 保存资源
		// 构造函数
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
			, _pmtx(new mutex)
		{}


		// 析构函数
		// 释放资源
		~shared_ptr()
		{
			Release();
		}

		// 拷贝构造
		// sp2(sp1)
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
			, _pmtx(sp._pmtx)
		{
			// 使用锁对++进行保护
			// 多个线程只能够串联执行
			_pmtx->lock(); 
			++(*_pcount);
			_pmtx->unlock();
		}

		void Release()
		{
			// 每个线程都有自己的独立栈结构，因此每个线程都有自己的flag，
			// 因此bool flag = false是没有线程安全问题的
			// 进程的堆空间，全局变量、静态变量是所有线程间共享的
			bool flag = false;

			_pmtx->lock();
			// *_pcount是堆上面的资源
			if (--(*_pcount) == 0)
			{
				delete _ptr;
				delete _pcount;

				// 当引用计数*_pcount为0时，此时我们不仅需要将_ptr和_pcount进行释放，
				// 还需要将锁进行释放，且必须是解锁之后，在释放锁，所以当*_pcount为0时
				// 将flag赋值为true，代表我们可以释放锁了
				flag = true;
			}
			_pmtx->unlock();

			if (flag == true)
			{
				delete _pmtx;
			}
		}

		// 赋值拷贝
		// sp1 = sp1;
		// sp1 = sp2;
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				Release();

				_pcount = sp._pcount;
				_ptr = sp._ptr;
				_pmtx = sp._pmtx;

				// 使用锁对++进行保护
				_pmtx->lock();
				++(*_pcount);
				_pmtx->unlock();
			}

			return *this;
		}

		int use_count() const
		{
			return *_pcount;
		}

		T* get() const
		{
			return _ptr;
		}

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

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

		T& operator[](size_t pos)
		{
			return _ptr[pos];
		}
	private:
		T* _ptr;
		int* _pcount;
		mutex* _pmtx;
	};

    // 链表的类
	struct ListNode
	{
		int val;
		shared_ptr<ListNode> _next;
		shared_ptr<ListNode> _prev;

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

	void test_shared_ptr2()
	{
        // n1和n2都是智能指针对象
		shared_ptr<ListNode> n1(new ListNode);
		shared_ptr<ListNode> n2(new ListNode);

        // n1->_next和n2->_prev 也是一个智能指针对象
        // 因此当赋值后，n1->_next和n2的引用计数都变为2
        // n2->_prev 和 n1同理
		n1->_next = n2;
		n2->_prev = n1;

		cout << n1.use_count() << endl;
		cout << n2.use_count() << endl;
	}
}
  • 打印结果
  • 通过打印结果我们可以得知，ListNode并没有被释放（没有打印析构函数中的~ListNode()）

image-20230815192006140

  • 原因：循环引用

image-20230815191755696

weak_ptr（解决shared_ptr的循环引用问题）

  • 注：
#pragma once

#include <thread>
#include <mutex>

// 1、RAII
// 2、像指针一样使用
// 3、拷贝问题
namespace qwy
{
    // 智能指针的类模板(shared_ptr的类模板)
	template<class T>
	class shared_ptr
	{
	public:
		// RAII
		// 保存资源
		// 构造函数
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
			, _pmtx(new mutex)
		{}


		// 析构函数
		// 释放资源
		~shared_ptr()
		{
			Release();
		}

		// 拷贝构造
		// sp2(sp1)
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
			, _pmtx(sp._pmtx)
		{
			// 使用锁对++进行保护
			// 多个线程只能够串联执行
			_pmtx->lock();
			++(*_pcount);
			_pmtx->unlock();
		}

		void Release()
		{
			// 每个线程都有自己的独立栈结构，因此每个线程都有自己的flag，
			// 因此bool flag = false是没有线程安全问题的
			// 进程的堆空间，全局变量、静态变量是所有线程间共享的
			bool flag = false;

			_pmtx->lock();
			// *_pcount是堆上面的资源
			if (--(*_pcount) == 0)
			{
				delete _ptr;
				delete _pcount;

				// 当引用计数*_pcount为0时，此时我们不仅需要将_ptr和_pcount进行释放，
				// 还需要将锁进行释放，且必须是解锁之后，在释放锁，所以当*_pcount为0时
				// 将flag赋值为true，代表我们可以释放锁了
				flag = true;
			}
			_pmtx->unlock();

			if (flag == true)
			{
				delete _pmtx;
			}
		}

		// 赋值拷贝
		// sp1 = sp1;
		// sp1 = sp2;
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				Release();

				_pcount = sp._pcount;
				_ptr = sp._ptr;
				_pmtx = sp._pmtx;

				// 使用锁对++进行保护
				_pmtx->lock();
				++(*_pcount);
				_pmtx->unlock();
			}

			return *this;
		}

		int use_count() const
		{
			return *_pcount;
		}

        // 拿到share_ptr管理的资源的指针
		T* get() const
		{
			return _ptr;
		}

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

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

		T& operator[](size_t pos)
		{
			return _ptr[pos];
		}
	private:
		T* _ptr;
		int* _pcount;
		mutex* _pmtx;
	};



    // weak_ptr的本质就是将share_ptr管理的资源进行管理
    // weak_ptr只负责管理，不负责释放这块资源
    // 释放资源还是由share_ptr在合适的时候进行释放
    // weak_ptr智能指针的类模板
	template<class T>
	class weak_ptr
	{
	public:
		// 构造函数
		weak_ptr()
			:_ptr(nullptr)
		{}

		// 拷贝构造
		// 通过sp.get()拿到shared_ptr管理的资源的指针，这样我们就可以对这块资源进行访问
		// 那么我们就需要对这块资源进行管理，也就不用释放这块资源了
		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;
		}
	public:
		T* _ptr;
	};

	struct ListNode
	{
		int val;
		// 可以指向资源/访问资源，不参与资源管理，不增加引用计数
		weak_ptr<ListNode> _next;
		weak_ptr<ListNode> _prev;

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

	void test_weak_ptr()
	{
        // n1和n2的引用计数都是1
		shared_ptr<ListNode> n1(new ListNode);
		shared_ptr<ListNode> n2(new ListNode);

        // n1->_next的类型是weak_ptr<ListNode>
        // 因此在赋值后，并不会增加n1的引用计数
		n1->_next = n2;
		n2->_prev = n1;
	}
    // 出函数的作用域后，先释放n1的资源，在n1中先释放n1的_next，这是一个weak_ptr的智能指针，只是将它管理的资源地址置空
}

// 打印结果为：
~ListNode()
~ListNode()
    // 说明将两个ListNode的资源都释放了

定制删除器

  • 演示1(正常运行结束)
#include<iostream>
#include<memory>
#include<string>

using namespace std;

int main()
{
    // 使用智能指针来管理这个string对象
	shared_ptr<string> sp2(new string);

	return 0;
}
  • 演示2(程序异常)
#include<iostream>
#include<memory>
#include<string>

using namespace std;

int main()
{
    // 使用智能指针来管理这个string对象
	shared_ptr<string> sp2(new string[10]);

	return 0;
}

image-20230815203711788

  • 这是因为，shared_ptr内部释放资源使用的是delete，而想要释放string[10]，则需要使用delete[],因此需要为智能指针管理的资源定制删除器

  • 解决方案（定制删除器）

    • 使用定制删除器之后，就可以完美的完成资源的释放
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<memory>
#include<string>

using namespace std;

// 定制删除器的类模板
template<class T>
struct DeleteArray
{
	void operator()(const T* ptr)
	{
		delete[] ptr;
		cout << "delete [] " << ptr << endl;
	}
};


int main()
{
    // 传入对应的定制删除器
	std::shared_ptr<int> sp1(new int[10], DeleteArray<int>());
	std::shared_ptr<string> sp2(new string[10], DeleteArray<string>());

	// 使用lambda表达式作为定制删除器
	std::shared_ptr<string> sp3(new string[10], [](string* ptr){delete[] ptr; });
    // 传入关闭文件的定制删除器
	std::shared_ptr<FILE> sp4(fopen("Test.cpp", "r"), [](FILE* ptr){fclose(ptr); });

	return 0;
}

test_shared_ptr3()

#pragma once

#include <thread>
#include <mutex>

// 1、RAII
// 2、像指针一样使用
// 3、拷贝问题
namespace qwy
{
	// 默认删除器的类模板
	template<class T>
	class default_delete
	{
	public:
		void operator()(T* ptr)
		{
			delete ptr;
		}
	};

    // shared_ptr的类模板
	// class D = default_delete<T> 是定制删除器的缺省模板
	template<class T, class D = default_delete<T>>
	class shared_ptr
	{
	public:
		// RAII
		// 保存资源
		// 构造函数
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
			, _pmtx(new mutex)
		{}


		// 析构函数
		// 释放资源
		~shared_ptr()
		{
			Release();
		}

		// 拷贝构造
		// sp2(sp1)
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
			, _pmtx(sp._pmtx)
		{
			// 使用锁对++进行保护
			// 多个线程只能够串联执行
			_pmtx->lock();
			++(*_pcount);
			_pmtx->unlock();
		}

		void Release()
		{
			// 每个线程都有自己的独立栈结构，因此每个线程都有自己的flag，
			// 因此bool flag = false是没有线程安全问题的
			// 进程的堆空间，全局变量、静态变量是所有线程间共享的
			bool flag = false;

			_pmtx->lock();
			// *_pcount是堆上面的资源
			if (--(*_pcount) == 0)
			{
				_del(_ptr);
				delete _pcount;

				// 当引用计数*_pcount为0时，此时我们不仅需要将_ptr和_pcount进行释放，
				// 还需要将锁进行释放，且必须是解锁之后，在释放锁，所以当*_pcount为0时
				// 将flag赋值为true，代表我们可以释放锁了
				flag = true;
			}
			_pmtx->unlock();

			if (flag == true)
			{
				delete _pmtx;
			}
		}

		// 赋值拷贝
		// sp1 = sp1;
		// sp1 = sp2;
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				Release();

				_pcount = sp._pcount;
				_ptr = sp._ptr;
				_pmtx = sp._pmtx;

				// 使用锁对++进行保护
				_pmtx->lock();
				++(*_pcount);
				_pmtx->unlock();
			}

			return *this;
		}

		int use_count() const
		{
			return *_pcount;
		}

		T* get() const
		{
			return _ptr;
		}

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

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

		T& operator[](size_t pos)
		{
			return _ptr[pos];
		}
	private:
		T* _ptr;
		int* _pcount;
		mutex* _pmtx;

		// 定制删除器
		D _del;
	};

	// 定制删除器
	template<class T>
	struct DeleteArray
	{
		void operator()(const T* ptr)
		{
			delete[] ptr;
			cout << "delete [] " << ptr << endl;
		}
	};

	// 定制删除器
	struct Fclose
	{
		void operator()(FILE* ptr)
		{
			fclose(ptr);
			cout << " 文件关闭 " << ptr << endl;
		}
	};

	struct ListNode
	{
		int val;

		weak_ptr<ListNode> _next;
		weak_ptr<ListNode> _prev;

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

	void test_shared_ptr3()
	{
		// 使用的是默认删除器，可以完美的释放资源
		qwy::shared_ptr<ListNode> n1(new ListNode);

		// 使用默认删除器，是无法释放资源的
		// 使用我们自定义的定制删除器则可以完美的释放资源
		// 我们的shared_ptr的定制删除器和c++库的简化，因此使用方式不一致，但是效果是一样的
		qwy::shared_ptr<ListNode,DeleteArray<ListNode>> n2(new ListNode[10]);

		qwy::shared_ptr<FILE, Fclose> n3(fopen("Test.cpp", "r"));

		// 但是这种实现方式无法使用lambda表达式
	}
}
the_nov
关注
  • 18
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11中的智能指针unique_ptr、shared_ptr和weak_ptr详解
dvlinker的技术专栏
05-28 3万+
详细讲解C++11中引入的智能指针unique_ptr、shared_ptr和weak_ptr。
C++ unique_ptr weak_ptr shared_ptr auto_ptr智能指针.doc
07-23
四种智能指针的使用、机制和缺陷分析
C++ 实现智能指针：shared_ptr 和 unique_ptr
12-20 2048
C++11 智能指针的深入分析，和动手实现简版的智能指针 std::shared_ptr 、std::unique_ptr
C++智能指针auto_ptr、unique_ptr、shared_ptr、weak_prt详解
GodFishhh的博客
02-03 1877
C++智能指针auto_ptr、unique_ptr、shared_ptr、weak_prt详解
智能指针简单实现unique_ptr和shared_ptr
yizhiniu_xuyw的专栏
06-23 1370
1 序 1.1 智能指针 为了避免手动在堆中分配出的内存没有释放造成内存泄露的问题，C++11提供了智能指针。 智能指针将指针封装成一个栈对象。栈对象在生命周期结束自动销毁时会调用析构函数。智能指针基本上也是在析构函数中做文章，实现的堆上内存管理。 C++11推荐使用的智能指针有unique_ptr、shared_ptr和weak_ptr三种。 1.2 内容简介 本文为std::unique_ptr的实现篇，介绍实现一个UniquePtr类，实现与std::unique_ptr类似的功能。代码实
C++11智能指针（auto_ptr,unique_ptr,shared_ptr,weak_ptr的详解与模拟实现）
yin_ming_hui的博客
10-01 666
概念：RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：不需要显式地释放资源。采用这种方式，对象所需的资源在其生命期内始终保持有效。
C++11新特性之智能指针(shared_ptr/unique_ptr/weak_ptr)
09-01
主要介绍了C++11新特性之智能指针,包括shared_ptr, unique_ptr和weak_ptr的基本使用，感兴趣的小伙伴们可以参考一下
【C++ 深入浅出】智能指针shared_ptr、unique_ptr、weak_ptr详解
01-07
C++ 11中最常用的智能指针类型为shared_ptr,它采用引用计数的方法，记录当前内存资源被多少个智能指针引用。该引用计数的内存在堆上分配。当新增一个时引用计数加1，当过期时引用计数减一。只有引用计数为0时，智能...
C++11 智能指针之shared_ptr代码详解
12-17
在新标准中，主要提供了shared_ptr、unique_ptr、weak_ptr三种不同类型的智能指针。 接下来的几篇文章，我们就来总结一下这些智能指针的使用。 今天，我们先来看看shared_ptr智能指针。 shared_ptr 智能指针 shared_...
IEN在Web3.0中的性能与安全优势
qq_29268247的博客
05-17 427
通过分布式架构、区块链技术和智能数据管理，IEN不仅提高数据传输效率和处理速度，还大幅增强网络安全性和稳定性。通过命名数据网络，IEN实现了高效的数据分发和缓存机制，减少了数据传输路径，提高了网络吞吐量。对比实验表明，IEN在处理并发请求时的延迟减少了40%，传输速率提高了30%。实验结果显示，面对突发流量时，IEN的吞吐量稳定性提高了35%，有效避免了网络拥塞。实验数据显示，IEN的加密机制将数据泄露事件减少了70%，大幅提升了数据隐私保护水平。IEN整合区块链技术，提供去中心化的信任机制。
解锁Nginx跨域谜题：3步打造安全高效的CORS策略
2401_85000826的博客
05-16 487
Nginx作为一款强大的Web服务器和反向代理服务器，经常被用于处理跨域资源共享（CORS，Cross-Origin Resource Sharing）策略，以允许或限制不同源之间的资源请求。CORS是一种安全策略，用于决定Web浏览器是否应允许从一个域名加载的网页访问另一个域名下的资源。下面将深入解析如何在Nginx配置中实现对origin（请求来源）的限制，以精确控制跨域请求。
软考高级架构师：软件系统安全相关概念完整性、不可否认性、可控性、机密性、安全审计
明明如月的技术博客
05-19 216
了解软件系统安全的几个重要概念：完整性、不可否认性、可控性、机密性和安全审计，可以通过一些日常生活中的例子来帮助理解。
【Linux安全】Firewalld防火墙基础
最新发布
weixin_62922268的博客
05-23 248
支持网络区域所定义的网络链接以及接口安全等级的动态防火墙管理工具支持IPv4、IPv6防火墙设置以及以太网桥支持服务或应用程序直接添加防火墙规则接口拥有两种配置模式运行时配置永久配置trusted（信任区域）：允许所有的传入流量。public（公共区域）：允许与ssh或dhcpv6-client预定义服务匹配的传入流量，其余均拒绝。是新添加网络接口的默认区域。external（外部区域）：允许与 ssh 预定义服务匹配的传入流量，其余均拒绝。
什么样的数据摆渡设备，可以满足不同网间数据的安全传输需求？
文件数据安全交换
05-23 238
飞驰云联是中国领先的数据安全传输解决方案提供商，长期专注于安全可控、性能卓越的数据传输技术和解决方案，公司产品和方案覆盖了跨网跨区域的数据安全交换、供应链数据安全传输、数据传输过程的防泄漏、FTP的增强和国产化替代、文件传输自动化和传输集成等各种数据传输场景。专业的跨网文件交换平台：比如飞驰云联《Ftrans Ferry跨网文件安全交换系统》：提供企业文件交换、病毒查杀、文件内容检测、审核审批、权限管控、日志审计等功能，实现安全、高效、可靠、便捷的文件交换。同时支持会签、或签，支持转审，可设置抄送人。
【安全警钟】APP如何筑起坚不可摧的防御，抵御黑客攻击？
NSME1的博客
05-20 442
做好安全防御
等保测评-安全通信网络与安全区域边界
2403_84237550的博客
05-23 472
等保测评，全称为网络安全等级保护测评，是中国网络安全领域的一项重要工作，旨在通过标准化的测评流程，确保信息系统的安全等级保护措施符合国家相关标准。在等保测评中，"安全通信网络"与"安全区域边界"是两个关键的测评领域。
分享 | 如何提升金融业务效率的同时保障身份认证安全和用户体验（二）
trusfort的博客
05-20 357
提升身份认证安全性，保证交易安全
军工单位如何做到安全跨网文件交换与导出的
镭速的博客
05-23 165
在现代信息化战争中，军工单位在信息安全方面的需求尤为突出。跨网文件交换与导出作为军工单位日常运营的重要环节，面临着网络带宽限制、数据安全风险、合规性要求和传输稳定性等挑战。下面，我们将从以下几个方面探讨军工单位如何实现安全、高效的跨国文件交换与导出。
Llama 3 模型家族构建安全可信赖企业级AI应用之 Code Llama （一）
段智华的博客
05-17 887
1、Llama开源模型家族大模型技术、工具和多模态详解：学员将深入了解Meta Llama 3的创新之处，比如其在语言模型技术上的突破，并学习到如何在Llama 3中构建trust and safety AI。8、Llama 3中的DPO原理、算法、组件及具体实现及算法进阶：学习Llama 3中结合使用PPO和DPO算法，剖析DPO的原理和工作机制，详细解析DPO中的关键算法组件，并通过综合项目八从零开始动手实现和测试DPO算法，同时课程将解密DPO进阶技术Iterative DPO及IPO算法。
详细说明智能指针unique_ptr和shared_ptr的构造方法
05-23
智能指针是C++11中引入的一个重要特性，用于管理动态分配的内存。...以上是智能指针unique_ptr和shared_ptr的构造方法，需要注意的是，使用智能指针时不需要手动释放内存，智能指针会自动管理内存。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值