智能指针（内存泄漏问题）

原创 于 2024-11-01 22:00:00 发布 · 1.1k 阅读 · 28 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #算法 #开发语言

🌻个人主页：路飞雪吖~

       🌠专栏：C/C++

目录

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

二、内存泄露

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

⭐RAII

⭐智能指针的原理

🌠小贴士：

⭐std::auto_ptr

​编辑 ✨auto_ptr模拟实现

⭐std::unique_ptr

✨unique_ptr 的模拟实现

⭐std::shared_ptr

✨std::shared_ptr的模拟实现

🌠小贴士：

✨std::shared_ptr的循环引用问题

 ✨std::weak_ptr的模拟实现

四、C++11和boost中智能指针的关系

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

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

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

void Func()
{
 // 1、如果p1这里new 抛异常会如何？
 // 2、如果p2这里new 抛异常会如何？
 // 3、如果div调用这里又会抛异常会如何？
 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;
}

1、如果p1这里new 抛异常会如何？不用管，因为还没有东西申请出来。
2、如果p2这里new 抛异常会如何？要先释放p1。

3、如果div调用这里又会抛异常会如何？ 要释放p1和p2。

二、内存泄露

⭐内存泄露的危害

• 什么是内存泄漏？

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

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

void MemoryLeaks()
{
   // 1.内存申请了忘记释放
  int* p1 = (int*)malloc(sizeof(int));
  int* p2 = new int;
  
  // 2.异常安全问题
  int* p3 = new int[10];
  
  Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
  
  delete[] p3;
}

⭐内存泄露的分类

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

• 堆内存泄漏(Heap leak)

      堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一 块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分 内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

• 系统资源泄漏

     指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放 掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

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

⭐RAII

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

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

• 不需要显式的释放资源；

• 采用这种方式，对象所需的资源在其生命期内始终保持有效。

// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
    SmartPtr(T* ptr = nullptr)// 在对象构造时获取资源
       : _ptr(ptr)
   {}

    ~SmartPtr() // 最后在对象析构的时候释放资源
   {
        if(_ptr)
            delete _ptr;
   }
    
private:
    T* _ptr;
};

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

void Func()
{
    ShardPtr<int> sp1(new int);
    ShardPtr<int> sp2(new int);
    cout << div() << endl;
}

// 好处：
// 不需要显式地释放资源
// 采用这种方式，对象所需的资源在其生命期内始终保持有效

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

⭐智能指针的原理

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

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

 ~SmartPtr()
 {
     if(_ptr)
         delete _ptr;
 }
 
 T& operator*() {return *_ptr;}
 T* operator->() {return _ptr;}

private:
 T* _ptr;
};
struct Date
{
    int _year;
 int _month;
 int _day;
};

int main()
{
 SmartPtr<int> sp1(new int);
 *sp1 = 10
 cout<<*sp1<<endl;
 
 SmartPtr<int> sparray(new Date);
 // 需要注意的是这里应该是sparray.operator->()->_year = 2018;
 // 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->
 sparray->_year = 2018;
 sparray->_month = 1;
 sparray->_day = 1;
}
🌠小贴士：

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

1. RAII特性;

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

⭐std::auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针；

auto_ptr 的实现原理：管理权转移的思想。

有些地方明确要求 禁止使用！

template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
	}
	T& operator*() { return *_ptr; }
	T* operator->() { return _ptr; }
private:
	T* _ptr;
};

struct Date
{
	int _year;
	int _month;
	int _day;

	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}

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

int main()
{
	//SmartPtr<Date> sp1(new Date);
	//SmartPtr<Date> sp2(sp1);//浅拷贝/值拷贝（sp1、sp2指向同一块空间，析构两次，导致程序错误）

	auto_ptr<Date> ap1(new Date);
	// 拷贝时，管理权限转移，被拷贝(ap1)悬空
	auto_ptr<Date> ap2(ap1);

	ap1->_year++;

	return 0;
}

 ✨auto_ptr模拟实现

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

		// sp1(sp2)
		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;
				
				// 转移ap中资源到当前对象中
				_ptr = ap._ptr;
				ap._ptr = NULL;
			}
			return *this;
		}

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

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

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

	private:
		T* _ptr;
	};
}

// 结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr
//int main()
//{
// std::auto_ptr<int> sp1(new int);
// std::auto_ptr<int> sp2(sp1); // 管理权转移
//
// // sp1悬空
// *sp2 = 10;
// cout << *sp2 << endl;
// cout << *sp1 << endl;
// return 0;
//}

⭐std::unique_ptr

C++11中开始提供更靠谱的unique_ptr；

unique_ptr的实现原理：简单粗暴的防拷贝。

🔥扩展：

Boost库：为C++语言标准库提供扩展C++程序库的总称。

 Boost库是为C++语言标准库提供扩展的一些C++程序库的总称，由Boost社区组织开发、维护。Boost库可以与C++标准库完美共同工作，并且为其提供扩展功能。

Boost功能引入C++11

scoped_ptr /

scoped_array

禁止拷贝unique_ptr

shared_ptr /

shared_array

引用计数的方式支持shared_ptr
weak_ptr

不同于上面的智能指针，

不支持直接管理资源，

配合解决 shared_ptr 的一个缺陷，

循环引用会导致内存泄露。 

weak_ptr

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

class Fclose
{
public:
	void operator()(FILE* ptr1)
	{
		cout << "fclose:" << ptr1 << endl;
		Fclose(ptr);
	}
};

int main()
{
	// C++11
	unique_ptr<Date> up1(new Date);

	// 不支持拷贝(拷贝会被悬空)
	//auto_ptr<Date> up2(up1);

	//定制删除器
	//unique_ptr<Date, DeleteArray<Date>> up2(new Date[5]);// delete[] 不匹配，要单独写
	unique_ptr<Date[]> up2(new Date[5]);//调用特化版本
	unique_ptr<FILE, Fclose> up3(fopen("test.cpp","r"));
}

✨unique_ptr 的模拟实现

// C++11库才更新智能指针实现
// C++11出来之前，boost搞除了更好用的scoped_ptr/shared_ptr/weak_ptr
// C++11将boost库中智能指针精华部分吸收了过来
// C++11->unique_ptr/shared_ptr/weak_ptr

// unique_ptr/scoped_ptr
// 原理：简单粗暴 -- 防拷贝

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

		~unique_ptr()
		{
			if (_ptr)
			{
				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;
	};
}

int main()
{
	xlf::unique_ptr<int> sp1(new int);
	//xlf::unique_ptr<int> sp2(sp1);不能进行拷贝

	std::unique_ptr<int> sp1(new int);
	//std::unique_ptr<int> sp2(sp1);不能进行拷贝

	return 0;
}

⭐std::shared_ptr

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

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

 

int main()
{
	//vector<shared_ptr<Date>> v;  涉及左值右值要拷贝的场景
	shared_ptr<Date> sp1(new Date);
	shared_ptr<Date> sp2(sp1);// 多个对象共享资源
	shared_ptr<Date> sp3(sp2);
	cout << sp1.use_count() << endl;

	shared_ptr<Date[]> sp4(new Date[5]);
	//shared_ptr<FILE, Fclose> up4(fopen("test.cpp", "r"));//不支持在类模板参数传，要在构造函数的参数去传
	shared_ptr<FILE> up4(fopen("test.cpp", "r"), Fclose());//要在构造函数的参数去传

	shared_ptr<Date> sp6 = make_shared<Date>(2024, 8, 5);

	return 0;
}

✨std::shared_ptr的模拟实现

☄️我们如何设计引用计数？

引用计数是共同管理一块资源，共同的一个技术，而不是各自有一个各自的技术。

 

 ☄️ 定制删除器如何设计？

采用function包装器：

#include<functional>
namespace xlf
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

		// D函数模板是给 del这个成员函数用的，不是给整个类用的
	    // 只有把D写成类模板才能用，但是库里面没有写成类模板，只有unique_ptr写成类模板
		template<class D>//定制删除器:即可调用对象
		shared_ptr(T* ptr, D del)//  困境：删除器要传到release,
			:_ptr(ptr)                   // release要给删除和operator=用，
			,_pcount(new int(1))        // 所以release要改变
		    ,_del(del)               //成员函数里面，一个类的要给另外一个类的用的话，要通过成员变量
		{}

		//sp2(sp1)
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
		{
			++(*_pcount);
		}

		void Release()
		{
			if (--(*_pcount) == 0)
			{
				//delete _ptr;

				_del(_ptr);

				delete _pcount;
				_ptr = nullptr;
				_pcount = nullptr;
			}
		}

		//sp1=sp3             const会引用左值也会引用右值
		shared_ptr& operator=(const shared_ptr<T>& sp)// 如果是一个右值可以转移资源
		{
			////造成内存泄露
			//_ptr = sp._ptr;
			//_pcount = sp._pcount;
			//++(*_pcount);
			//return *this;

			if (_ptr != sp._ptr)//防止自己给自己赋值
			{
				Release();

				_ptr = sp._ptr;
				_pcount = sp._pcount;
				++(*_pcount);
			}
			return *this;
		}

		~shared_ptr()
		{
			Release();
		}

		T* get() const
		{
			return _ptr;
		}

		int use_count() const 
		{
			return *_pcount;
		}

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


	private:
		T* _ptr;
		int* _pcount;//增加引用计数
		//D _del;可调用对象
		function<void(T* ptr)> _del = [](T* ptr) {delete ptr; };//删除器
	};
}
struct Date
{
	int _year;
	int _month;
	int _day;

	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}

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

class Fclose
{
public:
	void operator()(FILE* ptr1)
	{
		cout << "fclose:" << ptr1 << endl;
		Fclose(ptr);
	}
};

#include"shared_ptr.h"

int main()
{
	xlf::shared_ptr<Date> sp1(new Date);// 没传删除器，此时调用function(包装器)的默认构造，
	                                    // 但是function里面没有可调用对象，会报错，
										// 因此function要给缺省值_ptr,回调自己
	xlf::shared_ptr<Date> sp2(sp1);

	xlf::shared_ptr<Date> sp3(new Date);
	
	//自己给自己赋值
	sp3 = sp3;//出现问题，此时，sp3只有一个对象管理
	sp1 = sp2;

	sp1 = sp3;

	xlf::shared_ptr<FILE> sp5(fopen("test.cpp", "r"), Fclose());
	xlf::shared_ptr<int> sp6((int*)malloc(40), [](int* ptr)
		{
			cout << "free:" << ptr << endl;
			free(ptr);
		});

	return 0;
}

🌠小贴士：

严格来说，不是深拷贝的类都不需要移动构造，浅拷贝的类，移动构造和移动赋值都没有特别大的意义，所以不需要实现，编译器一般也不会默认生成。 

✨std::shared_ptr的循环引用问题

struct ListNode
{
	int _data;

	//ListNode* _next;
	//ListNode* _prev;

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

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


int main()
{
	//循环引用的场景---（互相指向）导致内存泄露

	//std::shared_ptr<ListNode> n1 = new ListNode;//不支持这样子给，因为它的构造加了explicit，所以不支持转换
	std::shared_ptr<ListNode> n1(new ListNode);
	std::shared_ptr<ListNode> n2(new ListNode);

	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;

	//n1->_next = n2;// 不能， n1->_next是原生指针   n2是智能指针对象，
	// 智能指针不能给原生指针，所以要把原生指针的类型改为智能指针

	//互相指向造成内存泄露（没有析构）
	n1->_next = n2;// error
	n2->_prev = n1;// error

	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;


	//std::weak_ptr<ListNode> wp(new ListNode);

	return 0;
}

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

原理就是：node1->_next = node2 和 node2->_prev = node1时 weak_ptr的_next和 _prev不会增加node1和node2的引用计数。 

struct ListNode
{
	int _data;

	// weak_ptr的特点，当你用shared_ptr赋值或者拷贝构造时，不增加引用计数
	// 意味着我指向了它，但是我不增加计数
	std::weak_ptr<ListNode> _next;
	std::weak_ptr<ListNode> _prev;


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

int main()
{
	//循环引用的场景---（互相指向）导致内存泄露

	std::shared_ptr<ListNode> n1(new ListNode);
	std::shared_ptr<ListNode> n2(new ListNode);

	n1->_next = n2;
	n2->_prev = n1;

	return 0;
}

 ✨std::weak_ptr的模拟实现

 weak_ptr的特点：当你用shared_ptr赋值或者拷贝构造时，不增加引用计数，意味着我指向了它，但是我不增加计数。

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

	weak_ptr(const shared_ptr<T>& sp)//拷贝构造
		:_ptr(sp.get())// 不增加 shared_ptr的引用计数,严格来说，weak_ptr是要拿到计数的，才能判断过期
	{}

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

private:
	T* _ptr = nullptr;
	T* _pcount;
};

四、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中的实现的。

如若对你有帮助，记得点赞、收藏、关注哦！

若有误，望各位，在评论区留言或者私信我 指点迷津！！！谢谢^ ^ ~

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值