首页 > 编程语言 >C++ 智能指针

C++ 智能指针

时间：2024-12-17 12:32:22浏览次数：5  
标签：int sp C++ 智能 内存 shared unique ptr 指针

目录

内存泄漏

内存泄漏分类（了解）

如何检测内存泄漏（了解）

如何避免内存泄漏

智能指针的使用及原理

RAII

std::auto_ptr(转移管理权, 不建议使用)

std::unique_ptr(防止拷贝)

std::shared_ptr(引用计数)

make_shared()

模拟实现shared_ptr

std::shared_ptr的循环引用(导致内存泄漏)

unique_ptr和shared_ptrd 定制删除器传的位置不同

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

内存泄漏

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

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

如何检测内存泄漏（了解）

如何避免内存泄漏

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

智能指针的使用及原理

RAII

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

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

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效。
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(转移管理权, 不建议使用)

https://cplusplus.com/reference/memory/auto_ptr/

C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。 auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原理

// C++98 管理权转移 auto_ptr
namespace BMH
{
 template<class T>
 class auto_ptr
 {
 public:
     auto_ptr(T* ptr)
     :_ptr(ptr)
     {}

     //p2(p1)
     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

https://cplusplus.com/reference/memory/unique_ptr/

unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理.

 C++11库才更新智能指针实现
 C++11出来之前，boost搞除了更好用的scoped_ptr / shared_ptr / weak_ptr
                        在C++11中分别对应        unique_ptr / shared_ptr / weak_ptr 

                        头文件<memory>

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

namespace BMH
{
 template<class T>
 class unique_ptr
 {
 public:
     unique_ptr(T* ptr)
     :_ptr(ptr)
     {}
     ~unique_ptr() 
     {
         if (_ptr)
         {
             cout << "delete:" << _ptr << endl;
             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()
//{
// /*BMH::unique_ptr<int> sp1(new int);
// BMH::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

https://cplusplus.com/reference/memory/shared_ptr/

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。例如： 老师晚上下课之前都会通知，让最后走的学生记得把门锁下。

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

make_shared()

shared_ptr<Date> sp(new Date{2024 12 16});
auto sp2 =make_shared_ptr<Date>(2024 12 17);

make_shared()函数的好处:会将动态开辟的对象和动态开辟的引用计数放在一起,减少内存碎片.

模拟实现shared_ptr

问题 : share_ptr有没有移动构造和移动赋值?

        首先我们没有写拷贝/赋值/析构,编译器才会自己生成移动构造和移动赋值.(但我们写了)

 其次引用计数已经是引用计数了,share_ptr的拷贝构造和正常的移动构造很相似.

浅拷贝的类,移动构造和移动赋值,意义不大.

我们在此实现的引用计数是动态开辟的int , 而库中使用了一个类shared_count来计数

#pragma once
#include<iostream>
#include<functional>

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

		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
		{
			++(*_pcount);//引用计数
		}

		写成函数模版
        定制删除器
		template<class D>
		shared_ptr(const shared_ptr<T>& sp ,D del)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
			,_del(del)
		{
			++(*_pcount);//引用计数
		}

		//sp2 = sp1
		//sp3 = sp3 资源相同不作处理
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				release();//先置空sp2
				_ptr = sp._ptr;
				_pcount = sp._pcount;
				_del = sp._del;
				++(*_pcount);
			}
			return *this;//返回
		}

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

		T* get()
		{
			return _ptr;
		}
		int use_count()
		{
			return *_pcount;
		}
		void release()
		{
			if ((*_pcount) == 1)
			{
				//delete _ptr;
				_del(_ptr);

				delete _pcount;
				_ptr = nullptr;
				_pcount = nullptr;
			}
			else
			{
				--(*_pcount);
			}
		}

		~shared_ptr()
		{
			release();
		}

		//思考_count怎么创建 Q1:创建成static行不行(肯定不行,static是属于整个类,属于所有对象)
		//Q2:在对象里能不能用int _count; (不行 ,这样就是每个对象各自有一个计数,不是每个资源共享一个引用计数)
		//动态开辟 ,公共计数
	private:
		T* _ptr;
		int* _pcount;
		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* ptr)
    {
        cout << "fclose:" << ptr << endl;
        fclose(ptr);
    }
};
int main()
{
    BMH::shared_ptr<Date> sp(new Date{2024,12,17});

    BMH::shared_ptr<Date> sp2 = sp;
    BMH::shared_ptr<Date>sp3(sp);
    BMH::shared_ptr<Date>sp4(new Date);

    sp4 = sp4;
    sp4 = sp;
    cout << sp.use_count() << endl;

    BMH::shared_ptr<FILE> sp5(fopen("test.cpp", "r"), Fclose());//定制删除器
    BMH::shared_ptr<int> sp6((int*)malloc(40), [](int* ptr) 
    	{
    		cout << "free:" << ptr << endl;
    		free(ptr);
    	});
    return 0;
}

std::shared_ptr的线程安全问题(还没学线程,以后会补)

std::shared_ptr的循环引用(导致内存泄漏)

所以这就叫循环引用，谁也不会释放,导致内存泄漏.

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

weak_ptr 不能直接管理资源(不支持Raii),配合解决shared_ptr的循环引用.

  原理就是weak_ptr特性 (使用share_ptr构造weak_ptr时 ,不会增加引用计数)  

node1->_next = node2;和node2->_prev = node1;时 weak_ptr的_next和 _prev不会增加node1和node2的引用计数。

unique_ptr和shared_ptrd 定制删除器传的位置不同

shared_ptr的定制删除器传在构造函数参数列表中

unique_ptr的定制删除器传在模版参数中

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

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

	unique_ptr<Date> up1(new Date);
	// 不支持拷贝
	//unique_ptr<Date> up2(up1);

	// 定制删除器
	unique_ptr<Date, DeleteArray<Date>> up2(new Date[5]);
	unique_ptr<Date[]> up3(new Date[5]);
	unique_ptr<FILE, Fclose> up4(fopen("test.cpp", "r"));

	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> sp5(fopen("test.cpp", "r"), Fclose());

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

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

标签：int,sp,C++,智能,内存,shared,unique,ptr,指针
From： https://blog.csdn.net/m0_73751295/article/details/144523683

相关文章

  • 打卡信奥刷题（435）用C++信奥B4006[普及组/提高] [GESP202406 四级] 宝箱
    [GESP202406四级]宝箱题目描述小杨发现了nnn个宝箱，其中第iii......
  • 在CodeBolcks+Windows API下的C++面向对象的编程教程——给你的项目中添加头文件和菜
    0.前言我想通过编写一个完整的游戏程序方式引导读者体验程序设计的全过程。我将采用多种方式编写具有相同效果的应用程序，并通过不同方式形成的代码和实现方法的对比来理解程序开发更深层的知识。了解我编写教程的思路，请参阅体现我最初想法的那篇文章中的“1.编程计划”：学习编程......
  • C++快速失败策略
    函数一种推荐的策略是，遇到错误时尽快退出。一般来说这个叫快速失败策略。比较懒的人很难一直遵循这个规则，所以不如直接写个宏吧。#include<iostream>//尽早退出#defineRET_IF(_CONDITION_,RET_VALUE,...)\do{\if(......
  • 机器学习在运维中的实时分析应用：新时代的智能运维
    随着信息化和互联网技术的迅猛发展，运维工作的复杂性和重要性不断提升。传统的运维方法已经无法满足现代企业对于系统高效、稳定运行的需求。借助机器学习技术，实时分析在运维中的应用为智能运维带来了新的契机。本文将详细探讨机器学习在运维中的实时分析应用，并通过具体代码......
  • F5的WAF产品具有丰富的功能：攻击防护功能、智能检测与分析功能、安全管理与配置功能、A
    攻击防护功能防范常见Web攻击：能有效检测和阻止如SQL注入、跨站脚本攻击（XSS）、文件上传漏洞、命令注入等各类常见的Web应用攻击。通过对HTTP/HTTPS请求的深度分析，包括请求头、请求体、URL参数等，与预定义的攻击签名和规则进行精准匹配，及时发现并阻断恶意请求。抵御应用层DDoS攻击：......
  • 【人工智能学习之HDGCN训练自己的数据集】
    【人工智能学习之HDGCN训练自己的数据集】HD-GCN准备事项项目代码开源数据集第一行：帧数第二行：body数第三行：关节附加信息第四行：关节数5-29行：每个关节的数据之后的帧总结：自定义2D数据集模型移植与修改文件移动文件修改成功运行HD-GCNHD-GCN的核心在于其独特的HD-Gra......
  • SSM高校社团学生会管理系统--47676（免费领源码）可做计算机毕业设计JAVA、PHP、爬虫、APP
    摘  要本论文基于SSM框架，设计和实现了一个高校社团学生会管理系统。该系统旨在提供一个全面、高效、智能的高校社团学生会管理平台，以便管理者可以迅速且便捷地进行各项管理工作，并及时向社团成员提供准确的社团信息。  该系统通过角色划分为社团成员、社团社长和管理员......
  • 在CodeBolcks+Windows API下的C++面向对象的编程教程——用面向对象的方法改写用向导
    0.前言我想通过编写一个完整的游戏程序方式引导读者体验程序设计的全过程。我将采用多种方式编写具有相同效果的应用程序，并通过不同方式形成的代码和实现方法的对比来理解程序开发更深层的知识。了解我编写教程的思路，请参阅体现我最初想法的那篇文章中的“1.编程计划”：学习编程......
  • c++容器调用clear会释放内存吗
    只有含reserve()/capacity()成员函数的容器才需要用swapidiom来释放空间，而C++里只有vector和string这两个符合条件。在C++11中可以直接使用shrink_to_fit()。list/deque/set/map等容器是没有reserve()和capacity()这两个成员函数的，因此swap是无用功（除非用......
  • 智能化系统集成项目经理的基础技能
    工信教考中心，作为工业和信息化部直属事业单位，承担着工业、通信业和信息化系统专业人才培训及相关资格考试的重任。在智能化系统集成项目中，项目经理扮演着至关重要的角色，他们不仅需要具备深厚的技术功底，还要拥有出色的管理和协调能力。智能化系统集成项目经理的职责是多方面的......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99