C++智能指针相关内容整理分析

最新推荐文章于 2023-06-18 14:25:10 发布
最新推荐文章于 2023-06-18 14:25:10 发布
阅读量107 收藏 4
点赞数 2
分类专栏： C++日常笔记 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sakeww/article/details/125643653
版权

目录

1.为什么需要智能指针？(引入)

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

	delete p1;
	delete p2;
	delete p3;
}
int main()
{
	try {
		func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

在p1，p2和p3的new中，可能会导致失败，那么我们按照
C++异常的处理方式
那就只能调用大量的 try catch 语句

2. 内存泄漏

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

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

2.2 内存泄漏分类（了解）

C/C++程序中一般我们关心两种方面的内存泄漏：
堆内存泄漏(Heap leak)
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
系统资源泄漏
指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

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

在linux下内存泄漏检测：linux下几款内存泄漏检测工具
在windows下使用第三方工具：VLD工具说明
其他工具：内存泄漏工具比较

2.4如何避免内存泄漏

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

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

3.智能指针的使用及原理

3.1 RAII

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：
不需要显式地释放资源。
采用这种方式，对象所需的资源在其生命期内始终保持有效

解决 引入 问题（大量try，catch）：（SmartPtr）

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

	~SmartPtr()
	{
		cout << "delete:" << _ptr << endl;
		delete _ptr;
	}
private:
	T* _ptr;
};
void func()
{
	int* p1 = new int;
	SmartPtr<int> sp1(p1);
	int* p2 = new int;
	SmartPtr<int> sp2(p2);
	SmartPtr<int> sp3(new int);
}
int main()
{
	try {
		func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

3.2 智能指针的原理

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

如何像指针一样使用，解引用，->

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

	~SmartPtr()
	{
		cout << "delete:" << _ptr << endl;
		delete _ptr;
	}
	// 像指针一样使用
	T& operator*()
	{
		return *_ptr;
	}

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

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

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

3.3 std::auto_ptr

3.3.1引入拷贝问题

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

	~SmartPtr()
	{
		cout << "delete:" << _ptr << endl;
		delete _ptr;
	}
	// 像指针一样使用
	T& operator*()
	{
		return *_ptr;
	}

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

int main()
{
	SmartPtr<int> sp1(new int);
	SmartPtr<int> sp2(sp1);
	return 0;
}

在这里插入图片描述
问题原因：delete了两次

3.3.2解决拷贝问题：

auto_ptr不能解决
namespace sakeww
{

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

		auto_ptr(auto_ptr<T>& sp)
			:_ptr(sp._ptr)
		{
			//管理权转移
			sp._ptr = nullptr;
		}

		~auto_ptr()
		{
			if(_ptr){
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}
		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
}
int main()
{
	sakeww::auto_ptr<int> sp1(new int);
	sakeww::auto_ptr<int> sp2(sp1);//管理权转移
	return 0;
}

新问题：
这样会让sp1悬空
当我们解引用sp1的时候，就会失败

结论：
auto_ptr是一个失败的设计，很多公司明确要求不能使用auto_ptr

3.4unique_ptr 直接不让拷贝

scoped_ptr boost库里面的
unique_ptr C++吸取boost里面的精华部分
这两个区别只有名字不同，内容是相同的

#include<memory> //unique_ptr
namespace sakeww
{
	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;
		}
	private:
		unique_ptr(const unique_ptr<T>& sp) = delete;

	private:
		T* _ptr;
	};
}

int main()
{
	sakeww::unique_ptr<int> upp1(new int);
	sakeww::unique_ptr<int> upp2(upp1);

	return 0;
}

3.5shared_ptr

3.5.1shared_ptr 可以拷贝 shared_ptr简单模拟

拷贝构造：引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
赋值：
在这里插入图片描述

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

		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pRefCount(sp._pRefCount)
		{
			++(*_pRefCount);
		}

		void Release()
		{
			if (--(*_pRefCount) == 0)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
				delete _pRefCount;
			}
		}

		//增加计数
		void AddRef()
		{
			++(*_pRefCount);
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//if (this != &sp)
			if (_ptr != sp._ptr)//防止 sp1 = sp2
			{
				Release();
				 
				_ptr = sp._ptr;
				_pRefCount = sp._pRefCount;
				AddRef();
			}
			return *this;
		}

		~shared_ptr()
		{
			Release();
		}
		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pRefCount;
	};
}
int main()
{
	sakeww::shared_ptr<int> sp1(new int);
	sakeww::shared_ptr<int> sp2(sp1);
	sakeww::shared_ptr<int> sp3(sp1);

	sakeww::shared_ptr<int> sp4(new int);
	sakeww::shared_ptr<int> sp5(sp4);

	sp1 = sp4;
	sp2 = sp4;
	sp3 = sp4;

	sp1 = sp1;//没有问题
	sp1 = sp2;//?
	return 0;
}

3.5.2shared_ptr线程安全问题

问题：
指向堆上资源的线程安全问题是访问的人处理的，智能指针不管，也管不了
引用计数的线程安全问题，是智能指针要处理的

多个线程中对同一个智能指针对象进行拷贝和析构时，++和–引用计数引用计数存在线程安全问题

#include<mutex>
namespace sakeww
{
	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<T>& sp)
			:_ptr(sp._ptr)
			, _pRefCount(sp._pRefCount)
			, _pmtx(sp._pmtx)
		{
			AddRef();
		}

		void Release()
		{
			_pmtx->lock();

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

				flag = true;
			}

			_pmtx->unlock();

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

		//增加计数
		void AddRef()
		{
			_pmtx->lock();
			++(*_pRefCount);
			_pmtx->unlock();
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//if (this != &sp)
			if (_ptr != sp._ptr)//防止 sp1 = sp2
			{
				Release();
				 
				_ptr = sp._ptr;
				_pRefCount = sp._pRefCount;
				_pmtx = sp._pmtx;
				AddRef();
			}
			return *this;
		}

		int use_count()
		{
			return *_pRefCount;
		}
		~shared_ptr()
		{
			Release();
		}
		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pRefCount;
		mutex* _pmtx;
	};
}

补充问题：
shared_ptr智能指针是线程安全的吗？
是的，引用计数的加减是加锁保护的。但是指向资源不是线程安全的。

3.5.3shared_ptr 循环引用问题 （weak_ptr）

weak_ptr的next和prev对象，可以访问指向节点资源，但是不参与节点资源释放管理，其实就是不增加计数

库里的：

struct ListNode
{
	int _val;
	//std::shared_ptr<ListNode> _next;
	//std::shared_ptr<ListNode> _prev;
	
	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;
}

自己模拟实现的：

namespace sakeww
{
	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<T>& sp)
			:_ptr(sp._ptr)
			, _pRefCount(sp._pRefCount)
			, _pmtx(sp._pmtx)
		{
			AddRef();
		}

		void Release()
		{
			_pmtx->lock();

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

				flag = true;
			}

			_pmtx->unlock();

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

		//增加计数
		void AddRef()
		{
			_pmtx->lock();
			++(*_pRefCount);
			_pmtx->unlock();
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//if (this != &sp)
			if (_ptr != sp._ptr)//防止 sp1 = sp2
			{
				Release();

				_ptr = sp._ptr;
				_pRefCount = sp._pRefCount;
				_pmtx = sp._pmtx;
				AddRef();
			}
			return *this;
		}

		int use_count()
		{
			return *_pRefCount;
		}
		~shared_ptr()
		{
			Release();
		}
		T& operator*()
		{
			return *_ptr;
		}

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

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

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


	private:
		T* _ptr;
	};
}

struct ListNode
{
	int _val;

	sakeww::weak_ptr<ListNode> _next;
	sakeww::weak_ptr<ListNode> _prev;

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

int main()
{
	sakeww::shared_ptr<ListNode> n1(new ListNode);
	sakeww::shared_ptr<ListNode> n2(new ListNode);

	//循环引用
	n1->_next = n2;
	n2->_prev = n1;
	return 0;
}

3.6定制删除器

默认情况下，智能指针底层都是delete资源
如果你的资源不是new出来的呢？（new[],malloc,fopen）

定制删除器–可调用对象

namespace sakeww
{
	template<class T>
	class DefaultDelete
	{
	public:
		void operator()(const T* ptr)
		{
			cout << "delete:" << ptr << endl;
			delete ptr;
		}
	};

	//释放方式 由D删除器决定
	template<class T, class D = DefaultDelete<T>>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}

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

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

		T* operator->()
		{
			return _ptr;
		}
	private:
		unique_ptr(const unique_ptr<T>& sp) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;

	private:
		T* _ptr;
	};
} 

class A
{
public:
	A() { cout << "A()" << endl; }
	~A() { cout << "~A()" << endl; }
private:
	int _a1 = 0;
	int _a2 = 0;
};

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



struct DeleteFile
{
	void operator()(FILE* ptr)
	{
		cout << "fclose:" << ptr << endl;
		fclose(ptr);
	}
};


int main()
{
	// 删除器在类模板参数给 -- 类型
	sakeww::unique_ptr<A> up1(new A);
	sakeww::unique_ptr<A, DeleteArray<A>> up2(new A[10]);
	sakeww::unique_ptr<FILE, DeleteFile> up3(fopen("test.txt", "w"));

	// 删除器在构造函数的参数给 -- 对象
	std::shared_ptr<A> sp1(new A);
	std::shared_ptr<A> sp2(new A[10], DeleteArray<A>());
	std::shared_ptr<FILE> sp3(fopen("test.txt", "w"), DeleteFile());

	std::shared_ptr<A> sp4(new A[10], [](A* p) {delete[] p; });
	std::shared_ptr<FILE> sp5(fopen("test.txt", "w"), [](FILE* p) {fclose(p); });

	return 0;
}

4.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中的实现的
sakeww
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C++智能指针
weixin_46107667的博客
04-19 613
智能指针一、内存泄漏1.1什么是内存泄漏，内存泄漏的危害1.2内存泄漏类型1.3 内存泄漏的原因二、智能指针的使用原理2.1 SmartPtr2.2 std::auto_ptr2.3 std::unique_ptr2.4 shared_ptr三、总结：四种智能指针的实现原理 智能指针也是指针的一种，主要功能是将管理的资源能被对象访问，但是不会产生内存泄漏的问题。 一、内存泄漏 1.1什么是内存泄漏，内存泄漏的危害 什么是内存泄漏 内存泄漏就是因为守护造成程序未能释放已经不再使用的内存的情况。内存泄漏并不
c+智能指针源码分析_C ++中的智能指针
从零开始的教程世界
07-21 1899
c+智能指针源码分析In this article, we’ll take a look at how we can use Smart Pointers in C++. 在本文中，我们将研究如何在C ++中使用智能指针 。 Smart Pointers are an abstract interface to actual pointers (also called raw pointers)...
c++智能指针
xiami
02-23 104
智能指针的使用及原理 RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句 柄、网络连接、互斥量等等）的简单技术。 在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的 时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法...
c++ 智能指针
QtHalcon
11-28 206
https://www.cnblogs.com/TenosDoIt/p/3456704.html https://blog.csdn.net/tanswer_/article/details/79039617                
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
C++线程安全问题及解决方法，C++智能指针
11-30
对于C++智能指针作出了简要介绍。同时整理了相关的例子帮助理解。适用人群：有一定的编程基础，工作1-3年的研发人员。能学到什么：了解C++线程安全问题的原因，以及掌握解决线程安全问题的方法。同时能够掌握一下锁...
C++面试相关知识点整理.zip
01-20
5. **内存管理**：理解动态内存分配（new/delete）、智能指针（如unique_ptr、shared_ptr、weak_ptr）以及内存泄漏的预防是高级C++程序员的必备技能。 6. **异常处理**：学习如何使用try、catch和throw来处理运行时...
C++八股文整理（面试必备）
最新发布
05-13
综上所述，智能指针是C++中一种重要的工具，它不仅能够帮助开发者更好地管理内存，还能应用于多种场景，包括但不限于数据结构与算法、计算机网络、操作系统、数据库以及设计模式等领域。通过掌握智能指针的不同类型...
C++面试知识点整理.zip
01-20
3. **内存管理**：C++允许直接操作内存，理解堆和栈的区别，知道何时使用new和delete，以及智能指针（shared_ptr、unique_ptr、weak_ptr）的使用，能避免内存泄漏和悬挂指针的问题。 4. **STL（Standard Template ...
C++：智能指针
weixin_43908419的博客
06-06 5229
本文介绍了智能指针的概念和原理，以及C++标准库中的auto_ptr、unique_ptr和shared_ptr三种智能指针，分析了shared_ptr中的循环引用问题，并由shared_ptr的循环引用问题出发点，介绍了weak_ptr。
c++智能指针_C ++智能指针
cunchi8090的博客
07-19 380
c++智能指针This article is a discussion on smart pointers, what they are and why they are important to C++ programmers. Following the primary discussion I present a simple implementation of a reference co...
C++智能指针-保姆级讲解带你一文搞懂智能指针（附核心代码实现+讲解）
广西彭于晏的博客
06-18 2897
什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死// 1.内存申请了忘记释放 int * p1 =(int *) malloc(sizeof(int));
C++ 智能指针详解
freeking101的博客
01-24 8269
参考：C++ 智能指针详解_c++智能指针 数组_xt_xiaotian的博客-CSDN博客这篇博客主要参考上面这个博客和 《Boost 程序库完全开发指南：深入 C++ 准标准库 》 第三版 一个智能指针就是一个C++的对象，这个对象的行为像一个指针，但是它却可以在其不需要的时候自动删除。注意这个“其不需要的时候”， 这可不是一个精确的定义。这个不需要的时候可以指好多方面：局部变量退出函数作用域、类的对象被析构……。
c++智能指针详解
qq_44698445的博客
07-21 561
指针一直都是c\c++头疼的东西，虽然方便，但是能不用动态内存分配就不用，因为你new 多了后在释放后程序中就会有很多碎片，而且释放已经引用会使用不规范会导致程序崩溃 C++后面其实有很多东西都是从很老版本的boost库引入进来了，比如functional 智能指针等等 智能指针就是采用了RAII思想下期再讲 因为raw指针经常会导致内存泄漏，非法内存访问，多次释放同一块内存，释放非法动态内存等问题 C++通过模板提供了更加方便的对raw指针包装的智能指针，作为对象 他使用上类似raw指针 可以避免raw指
c语言智能指针是什么,C++ 智能指针深入解析
weixin_39891694的博客
05-20 390
1. 为什么需要智能指针？简单的说，智能指针是为了实现类似于Java中的垃圾回收机制。Java的垃圾回收机制使程序员从繁杂的内存管理任务中彻底的解脱出来，在申请使用一块内存区域之后，无需去关注应该何时何地释放内存，Java将会自动帮助回收。但是出于效率和其他原因(可能C++设计者不屑于这种傻瓜氏的编程方式)，C++本身并没有这样的功能，其繁杂且易出错的内存管理也一直为广大程序员所诟病。更进一步地说...
C/C++语言篇：4种智能指针
qq_27446275的博客
07-24 348
C++中主要用New和Delete来分配和释放内存，但是有时候我们常常忘记Delete而造成内存泄露。为了避免这个问题，C++引入了智能指针模板类来管理动态内存。C++中智能指针有四种：auto_ptr，unique_ptr、share_ptr、weak_ptr。 1、auto_ptr（C++98的方案，C++11已放弃） auto_ptr要求对它拥有的指针完全占用，两个auto_ptr不能同时...
C++中的智能指针
imp0128的博客
07-15 249
C++中的智能指针1.为什么要使用智能指针?2.智能指针的使用及其原理2.1RAII2.2智能指针的使用及原理3.C++中常见的智能指针3.1auto_ptr3.1.1 auto_ptr的实现原理3.1.1auto_ptr的缺陷:3.2unique_ptr3.3shared_ptr3.3.1shared_ptr中的循环引用的问题 1.为什么要使用智能指针? 先来看一段代码,分析这段代码有没有内存上的错误? #include <iostream> using namespace std; void
C++智能指针详解
热门推荐
locahuang的博客
07-23 3万+
1、概述 我们知道除了静态内存和栈内存外，每个程序还有一个内存池，这部分内存被称为自由空间或者堆。程序用堆来存储动态分配的对象即那些在程序运行时分配的对象，当动态对象不再使用时，我们的代码必须显式的销毁它们。 在C++中，动态内存的管理是用一对运算符完成的：new和delete。 new：在动态内存中为对象分配一块空间并返回一个指向该对象的指针; delete：指向一个动态独享的指针，销毁对象，并释放与之关联的内存。 动态内存管理经常会出现两种问题： （1）一种是忘记释放内存，会造成内存泄漏； （2）一..
C++面试突击指南：全面解析与智能指针详解
书中内容涵盖了C++语言的基础部分，如智能指针的讲解。智能指针，如auto_ptr，是一种特殊类型的指针，设计目的是解决内存管理问题，避免程序员在函数结束时忘记释放内存导致的内存泄漏。智能指针作为类，当其作用域...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值