• C++11新特性之智能指针|内存泄漏

    文章目录

    一、智能指针

    二、内存泄漏

    1.什么是内存泄漏，内存泄漏的危害

    2.内存泄漏的分类

    3.避免内存泄漏的方案

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

    1.RAII

    2.智能指针的原理

    3.std::auto_ptr

    4.std::unique_ptr

    5.std::shared_ptr

    shared_ptr的线程安全问题

    shared_ptr中的循环引用

    6.std::weak_ptr

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

    一、智能指针

    二、内存泄漏

    1.什么是内存泄漏，内存泄漏的危害

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

    内存泄漏的危害：如os,后台服务等，出现内存泄漏会导致程序响应越来越慢，最终卡死。

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

    2.内存泄漏的分类

    1. 堆内存泄漏

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

    1. 系统资源泄漏      

            指程序使用系统分配的资源，比如套接字，fd,管道等没有使用对应函数释放，导致系统资源的浪费，严重可能导致系统效能减小，系统执行不稳定。

    3.避免内存泄漏的方案

    1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。 ps ：
    这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智
    能指针来管理才有保证。
    2. 采用 RAII 思想或者智能指针来管理资源。
    }
    3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
    4. 出问题了使用内存泄漏工具检测。 不过很多工具都不够靠谱，或者收费昂贵。

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

    1.RAII

    RAII是利用对象声明周期来控制程序资源，如内存，文件句柄，网络连接，互斥量等技术。在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。这种方法：1.不需要显示释放资源 2.采用这种方式，对象所需的资源在其声明周期内始终有效。

    2.智能指针的原理

    智能指针，即需要像指针一样解引用去访问空间所指的内容，因此在模板中需要*,->重载。

    智能指针的原理就是：

    1.RAII

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

    1. template<class T>
    2. class SmartPtr {
    3. public:
    4. SmartPtr(T* ptr = nullptr)
    5.      : _ptr(ptr)
    6.  {}
    7. ~SmartPtr()
    8.  {
    9.      if(_ptr)
    10.          delete _ptr;
    11.  }
    12. T& operator*() {return *_ptr;}
    13. T* operator->() {return _ptr;}
    14. private:
    15. T* _ptr;
    16. };

    3.std::auto_ptr

    c++98中的库就提供了auto_ptr的智能指针，auto_ptr的实现原理是：管理权转移的思想

    1. namespace jelly
    2. {
    3.     template<class T>
    4.     class auto_ptr
    5.     {
    6.         public:
    7.             auto_ptr(T* ptr)
    8.               :_ptr(ptr)
    9.             {}
    10.             ~auto_ptr()
    11.             {
    12.                 if(_ptr)
    13.                     delete _ptr;
    14.              }
    15.         
    16.             //管理权转移
    17.             auto_ptr(auto_ptr& ap)
    18.                 :_ptr(ap._ptr)
    19.             {
    20.                 ap._ptr = nullptr;
    21.             }
    22.  
    23.             T& operator*()
    24.             {
    25.                 return *ptr;
    26.             }
    27.  
    28.             T* operator->()
    29.             {
    30.                 return _ptr;
    31.             }
    32.  
    33.             private:
    34.                 T* _ptr;
    35. };
    36.  
    37. }

    这样会有问题，如下：

    1. int main()
    2. {
    3.     auto_ptr<int> sp1(new int);
    4.     auto_ptr<int> sp2(sp1); //管理权转移
    5.     //sp1悬空了
    6. }

    4.std::unique_ptr

    c++11中提供更靠谱的unique_ptr

    unique_ptr的实现原理：简单粗暴的防拷贝。模拟实现以下unique_ptr

    1. namespace jelly
    2. {
    3.  template<class T>
    4.  class unique_ptr
    5.  {
    6.  public:
    7.      unique_ptr(T* ptr)
    8.      :_ptr(ptr)
    9.      {}
    10.      ~unique_ptr()
    11.      {
    12.          if (_ptr)
    13.          {
    14.              cout << "delete:" << _ptr << endl;
    15.              delete _ptr;
    16.          }
    17.      }
    18.  
    19.  // 像指针一样使用
    20.  T& operator*(){ return *_ptr;}
    21.  T* operator->() { return _ptr;}
    22.  unique_ptr(const unique_ptr& sp) = delete;  //防止拷贝
    23.  unique_ptr& operator=(const unique_ptr& sp) = delete; //防止赋值
    24.  private:
    25.          T* _ptr;
    26.  };
    27. }

    5.std::shared_ptr

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

    shared_ptr原理：通过引用计数的方式来实现shared_ptr对象之间的共享资源。例如：办公室的老师晚上下班前会通知，最后走的学生锁门。

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

    2.在对象被销毁时（也就是析构函数调用）,就说明自己不使用该资源了，对象的引用计数--

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

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

    1. namespace jelly
    2. {
    3.     template<class T>
    4.     class shared_ptr
    5.     {
    6.         public:
    7.           shared_ptr(T * ptr)
    8.           :_ptr(ptr)
    9.           ,_pcount(new int(1))
    10.         {}
    11.  
    12.             ~shared_ptr()
    13.             {
    14.                 //析构的时候--计数
    15.                 if(--(*_pcount 0) )
    16.                 {
    17.  
    18.                     delete _pcount;      
    19.                     delete _ptr;
    20.                 }
    21.  
    22.  
    23.             shared_ptr(const shared_ptr & sp)  //拷贝构造
    24.                 :_ptr(sp.ptr)
    25.                 ,_pcount(sp._pcount)   //浅拷贝
    26.             {
    27.                 ++(*_pcount);
    28.             }
    29.     
    30.            //赋值
    31.            //shared_ptr sp1(new(int(1));
    32.            //shared_ptr sp2(new(int(2));
    33.            //shared_ptr sp4(new(int(10));
    34.            //sp1 = sp4;
    35.            //注意：1.sp1原来所指向的pcount--,sp4所指向的pcount++
    36.            //sp4 = sp1; sp4 --pcount == 0,自己原来的资源释放掉
    37.            //2.被复制的对象pcount--
    38.            shared_ptr & operator=(shared_ptr & sp)
    39.                 
    40.             {
    41.                 //自己不能给自己赋值
    42.                 if(sp._ptr != _ptr)  //资源的地址是一样的
    43.                 {
    44.                   if(--(*_pcount) == 0)
    45.                     {
    46.                         delete _ptr; //释放掉原来的资源
    47.                         delete _pcount; //释放掉计数
    48.                     }     
    49.                     _ptr = sp._ptr;
    50.                     _count = sp._count;
    51.                     ++（*_pcount);
    52.                 }
    53.                 
    54.  
    55.                 return *this;
    56.             }
    57.             
    58.             T& operator*()
    59.             {
    60.                 return *_ptr;
    61.             }
    62.  
    63.             T* operator->()
    64.             {
    65.                 return _ptr;
    66.             }
    67.  
    68.             
    69.  
    70.             }
    71.  
    72.         
    73.  
    74.  
    75.         private:
    76.             T* _ptr;
    77.             int * _pcount; //指向同一块计数
    78.      }；
    79. }

    shared_ptr的线程安全问题

    shared_ptr的线程安全分为两方面：

    1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中的智能指针引用计数同时++或--，这个操作不是原子的，这样引用计数就会错乱，会导致资源未释放或者程序崩溃，所以智能指针中的++或--需要加锁，也就是说引用计数的操作是线程安全的

    2.智能指针管理的对象存放在堆上，两个线程同时去访问，就会导致线程安全问题。

    所以shared_ptr增加了一个锁来解决这个问题

    1. #include
    2. #include
    3. #include
    4.  
    5. using namespace std;
    6. namespace jelly
    7. {
    8. 	//1.RAII
    9. 	//2.指针
    10. 	//3.拷贝
    11.  
    12. 	//shared_ptr本身是线程安全的
    13. 	//shared_ptr管理的对象不是线程安全的
    14. 	template<class T>
    15. 	class shared_ptr
    16. 	{
    17. 	public:
    18. 		shared_ptr(T* ptr)
    19. 			:_ptr(ptr)
    20. 			, _pcount(new int(1))
    21. 			,_pmtx(new mutex)
    22. 		{
    23. 		}
    24.  
    25.  
    26. 		void Release()
    27. 		{
    28. 			_pmtx->lock();
    29.  
    30. 			bool deleteFlag = false;
    31. 			if (--(*_pcount) == 0)
    32. 			{
    33. 				delete _ptr;
    34. 				delete _pcount;
    35.  
    36. 				deleteFlag = true;
    37. 			}
    38. 			_pmtx->unlock();
    39.  
    40. 			if (deleteFlag)
    41. 			{
    42. 				delete _ptmx;
    43. 			}
    44. 		}
    45.  
    46.  
    47. 		~shared_ptr()
    48. 		{
    49. 			Release();
    50. 		}
    51.  
    52.  
    53. 		void AddCount()
    54. 		{
    55. 			_pmtx->lock();
    56. 			++(*_pcount);
    57. 			_pmtx->unlock();
    58. 		}
    59. 		//拷贝构造
    60. 		shared_ptr(const shared_ptr& sp)
    61. 			:_ptr(sp._ptr)
    62. 			, _pcount(sp._pcount)
    63. 			,_pmtx(sp._pmtx)
    64. 		{
    65. 			//++(*_pcount);
    66. 			AddCount();
    67.  
    68. 		}
    69.  
    70. 		//赋值
    71. 		shared_ptr& operator = (const shared_ptr& sp)
    72. 		{
    73. 			//要判断是否是最后一个 
    74. 			//也要防止自己赋值给自己 这里用指针指向来判断
    75. 			if (sp._ptr != _ptr)
    76. 			{
    77. 				/*if (--(*_pcount) == 0)
    78. 				{
    79. 					delete _ptr;
    80. 					delete _pcount;
    81. 				}*/
    82. 				Release();
    83. 				_pcount = sp._pcount;
    84. 				_ptr = sp._ptr;
    85. 				//注意这里要拷贝锁的指针
    86. 				_pmtx = sp._pmtx;
    87. 				//++(*_pcount);
    88. 				AddCount();
    89. 			}
    90.  
    91. 			return *this;
    92. 		}
    93.  
    94.  
    95. 		T* operator->()
    96. 		{
    97. 			return _ptr;
    98. 		}
    99.  
    100. 		T& operator*()
    101. 		{
    102. 			return *_ptr;
    103. 		}
    104.  
    105. 		T* get()
    106. 		{
    107. 			return _ptr;
    108. 		}
    109.  
    110. 		int use_count()
    111. 		{
    112. 			return *_pcount;
    113. 		}
    114.  
    115. 	private:
    116. 		T* _ptr;
    117. 		int* _pcount;
    118. 		mutex* _pmtx;
    119.  
    120. 	};

    shared_ptr中的循环引用

    1. struct ListNode
    2. {
    3.  int _data;
    4.  shared_ptr _prev;
    5.  shared_ptr _next;
    6.  ~ListNode(){ cout << "~ListNode()" << endl; }
    7. };
    8.  
    9. int main()
    10. {
    11.  shared_ptr node1(new ListNode);
    12.  shared_ptr node2(new ListNode);
    13.  cout << node1.use_count() << endl;
    14.  cout << node2.use_count() << endl;
    15.  node1->_next = node2;
    16.  node2->_prev = node1;
    17.  cout << node1.use_count() << endl;
    18.  cout << node2.use_count() << endl;
    19.  return 0;
    20. }

    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的引用计数

    6.std::weak_ptr

    1. struct ListNode
    2. {
    3.  int _data;
    4.  weak_ptr _prev;
    5.  weak_ptr _next;
    6.  ~ListNode(){ cout << "~ListNode()" << endl; }
    7. };
    8. int main()
    9. {
    10.  shared_ptr node1(new ListNode);
    11.  shared_ptr node2(new ListNode);
    12.  cout << node1.use_count() << endl;
    13.  cout << node2.use_count() << endl;
    14.  node1->_next = node2;
    15.  node2->_prev = node1;
    16.  cout << node1.use_count() << endl;
    17.  cout << node2.use_count() << endl;
    18.  return 0;
    19. }

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

    1.c++98中产生了第一个智能指针auto_ptr

    2.c++boost给出了更实用的scoped_ptr和shared_ptr,weak_ptr

    3.c++TR1,引入了shared_ptr等

    4.c++11引入了unique_ptr和shared_ptr,weak_ptr。unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost实现的。

  • 相关阅读:
    送给女朋友的情话
    OmniPlan Pro for Mac v4.8.0中文激活版 项目流程管理工具
    计算机二级WPS 选择题（模拟和解析十三）
    调优C / C ++编译器以在多核应用程序中获得最佳并行性能：第一部分
    Web开发：＜p＞标签作用
    世上最全NVDIA GPU参数列表： 3090，4090， A40， A30，V100， A100， A800性能参数
    谁懂啊！自制的科普安全手册居然火了
    机器人迷雾之算力与智能
    LED圣诞灯饰出口欧洲CE认证检测项目标准
    物业一站式工单管理系统哪家好？如何提升物业管理和维修服务质量？
  • 原文地址：https://blog.csdn.net/jolly0514/article/details/133186241