C++智能指针

CPP 智能指针总结分享 CPP 智能指针 shared_ptr、unique_ptr、weak_ptr 总结梳理分享 阅读详情

目录

为什么需要智能指针

内存泄漏

什么是内存泄漏,内存泄漏的危害

内存泄漏分类

如何检测内存泄漏

如何避免内存泄漏

智能指针的使用及原理

RAII

智能指针的原理

std::auto_ptr

std::unique_ptr

std::shared_ptr

std::shared_ptr的线程安全问题

std::shared_ptr的循环引用

​std::weak_ptr

如果不是new出来的对象如何通过智能指针管理呢?

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


为什么需要智能指针

下面我们先分析一下下面这段程序有没有什么内存方面的问题?提示一下:注意分析MergeSort函数中的问题。

#include<iostream>
#include<vector>
#include<string>
using namespace std;
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 抛异常会如何?//p1没有被释放
	// 3、如果div调用这里又会抛异常会如何?//p1,p2没有被释放
	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;
}

内存泄漏

什么是内存泄漏,内存泄漏的危害

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

系统资源泄漏

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

如何检测内存泄漏

在linux下内存泄漏检测:Linux下几款C++程序中的内存泄露检查工具_testsuite kmalloc_CHENG Jian的博客-优快云博客
在windows下使用第三方工具:

VS编程内存泄漏:VLD(Visual LeakDetector)内存泄露库_波波在学习的博客-优快云博客
其他工具:

https://www.cnblogs.com/liangxiaofeng/p/4318499.html

如何避免内存泄漏

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

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

智能指针的使用及原理

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

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的使用及问题。
auto_ptr的实现原理:管理权转移的思想,下面简化模拟实现了一份auto_ptr来了解它的原理

// C++98  auto_ptr 管理权转移,被拷贝对象的出现悬空问题
// 很多公司是明确的要求了不能使用它
template<class T>
class auto_ptr
{
public:
	auto_ptr(T* ptr = nullptr)
		: _ptr(ptr)
	{}

	auto_ptr(auto_ptr<T>& ap)
		:_ptr(ap._ptr)
	{
		ap._ptr = nullptr;
	}

	// ap1 = ap2;
	auto_ptr<T>& operator=(auto_ptr<T>& ap)
	{
		if (this != &ap)
		{
			if (_ptr)
			{
				cout << "Delete:" << _ptr << endl;
				delete _ptr;
			}

			_ptr = ap._ptr;
			ap._ptr = nullptr;
		}

		return *this;
	}

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

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

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

private:
	T* _ptr;
};
int main()
{
	auto_ptr<int> ap1(new int);//有拷贝问题
	auto_ptr<int> ap2(ap1);
	//*ap1 = 10;出错
	//*ap2 = 20;
	return 0;
}

std::unique_ptr

C++11中开始提供更靠谱的unique_ptr
unique_ptr的实现原理:简单粗暴的防拷贝,下面简化模拟实现了一份UniquePtr来了解它的原理

// boost -- 探路者
// scoped_ptr/shared_ptr/weak_ptr

// C++11 -- 抄boost库的作业
// unique_ptr/shared_ptr/weak_ptr

template<class T>
class unique_ptr
{
private:
	// 防拷贝 C++98
	// 只声明不实现 
	//unique_ptr(unique_ptr<T>& ap);
	//unique_ptr<T>& operator=(unique_ptr<T>& ap);
public:
	unique_ptr(T* ptr = nullptr)
		: _ptr(ptr)
	{}

	// 防拷贝 C++11
	unique_ptr(unique_ptr<T>& ap) = delete;
	unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;

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

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

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

private:
	T* _ptr;
};

std::shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr
shared_ptr的原理:是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。例如:
老师晚上在下班之前都会通知,让最后走的学生记得把门锁下。

  • 1. shared_ptr在其内部,给每个资源都维护了着一份计数,用来记录该份资源被几个对象共享。
  • 2. 在对象被销毁时(也就是析构函数调用),就说明自己不使用该资源了,对象的引用计数减一。
  • 3. 如果引用计数是0,就说明自己是最后一个使用该资源的对象,必须释放该资源;
  • 4. 如果不是0,就说明除了自己还有其他对象在使用该份资源,不能释放该资源,否则其他对象就成野指针了。
template<class T, class D = Delete<T>>
class shared_ptr
{
public:
	shared_ptr(T* ptr = nullptr)
		: _ptr(ptr)
		, _pCount(new int(1))
	{}

	void Release()
	{
		if (--(*_pCount) == 0)
		{
			//cout << "Delete:" << _ptr << endl;
			//delete _ptr;

			//D del;
			//del(_ptr);
			D()(_ptr);

			delete _pCount;
		}
	}

	~shared_ptr()
	{
		Release();
	}

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

	// sp1 = sp5
	// sp1 = sp1
	shared_ptr<T>& operator=(const shared_ptr<T>& sp)
	{
		//if (this == &sp)
		if (_ptr == sp._ptr)
		{
			return *this;
		}

		// 减减被赋值对象的计数,如果是最后一个对象,要释放资源
		/*if (--(*_pCount) == 0)
		{
			delete _ptr;
			delete _pCount;
		}*/
		Release();

		// 共管新资源,++计数
		_ptr = sp._ptr;
		_pCount = sp._pCount;

		(*_pCount)++;

		return *this;
	}

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

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

	int use_count()
	{
		return *_pCount;
	}

	T* get() const
	{
		return _ptr;
	}

private:
	T* _ptr;

	// 引用计数
	int* _pCount;
};

shared_ptr智能指针是线程安全的吗?

  • 是的,引用计数的加减是加锁保护的。但是指向资源不是线程安全的
  • 指向堆上资源的线程安全问题是访问的人处理的,智能指针不管,也管不了,引用计数的线程安全问题,是智能指针要处理的
std::shared_ptr的线程安全问题

通过下面的程序我们来测试shared_ptr的线程安全问题。需要注意的是shared_ptr的线程安全分为两方面:

  • 1. 智能指针对象中引用计数是多个智能指针对象共享的,两个线程中智能指针的引用计数同时++或--,这个操作不是原子的,引用计数原来是1,++了两次,可能还是2.这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数++、--是需要加锁的,也就是说引用计数的操作是线程安全的。
  • 2. 智能指针管理的对象存放在堆上,两个线程中同时去访问,会导致线程安全问题
// 1.演示引用计数线程安全问题,就把AddRefCount和SubRefCount中的锁去掉
// 2.演示可能不出现线程安全问题,因为线程安全问题是偶现性问题,main函数的n改大一些概率就
//变大了,就容易出现了。
// 3.下面代码我们使用SharedPtr演示,是为了方便演示引用计数的线程安全问题,将代码中的
//SharedPtr换成shared_ptr进行测试,可以验证库的shared_ptr,发现结论是一样的。
struct Date
{
	int _year = 0;
	int _month = 0;
	int _day = 0;
};
void SharePtrFunc(chx::shared_ptr<Date>& sp, size_t n, mutex& mtx)
{
	cout << sp.get() << endl;
	for (size_t i = 0; i < n; ++i)
	{
		// 这里智能指针拷贝会++计数,智能指针析构会--计数,这里是线程安全的。
		chx::shared_ptr<Date> copy(sp);
		// 这里智能指针访问管理的资源,不是线程安全的。所以我们看看这些值两个线程++了2n
		//次,但是最终看到的结果,并一定是加了2n
		{
		unique_lock<mutex> lk(mtx);
		copy->_year++;
		copy->_month++;
		copy->_day++;
		}
	}
}
int main()
{
	chx::shared_ptr<Date> p(new Date);
	cout << p.get() << endl;
	const size_t n = 100000;
	mutex mtx;
	thread t1(SharePtrFunc, std::ref(p), n, std::ref(mtx));
	thread t2(SharePtrFunc, std::ref(p), n, std::ref(mtx));
	t1.join();
	t2.join();
	cout << p->_year << endl;
	cout << p->_month << endl;
	cout << p->_day << endl;
	cout << p.use_count() << endl;
	return 0;
}
std::shared_ptr的循环引用
struct ListNode
{
	int _data;
	shared_ptr<ListNode> _prev;
	shared_ptr<ListNode> _next;
	~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	node1->_next = node2;
	node2->_prev = node1;
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}

循环引用分析:

  • 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成员,所以这就叫循环引用,谁也不会释放。

 std::weak_ptr

// 辅助型智能指针,使命配合解决shared_ptr循环引用问题
	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{}

		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp.get())
		{}

		weak_ptr(const weak_ptr<T>& wp)
			:_ptr(wp._ptr)
		{}

		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;
	};
}

循环引用:

解决方案:在引用计数的场景下,把节点中的_prev和_next改成weak_ptr就可以了
原理就是,node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和
_prev不会增加node1和node2的引用计数。

如果不是new出来的对象如何通过智能指针管理呢?

其实shared_ptr设计了一个删除器来解决这个问题


// 仿函数的删除器
template<class T>
struct FreeFunc {
	void operator()(T* ptr)
	{
		cout << "free:" << ptr << endl;
		free(ptr);
	}
};
template<class T>
struct DeleteArrayFunc {
	void operator()(T* ptr)
	{
		cout << "delete[]" << ptr << endl;
		delete[] ptr;
	}
};
int main()
{
	FreeFunc<int> freeFunc;
	std::shared_ptr<int> sp1((int*)malloc(4), freeFunc);
	DeleteArrayFunc<int> deleteArrayFunc;
	std::shared_ptr<int> sp2((int*)malloc(4), deleteArrayFunc);
	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;
}

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中的实现的。
手把手教你用ECharts打造炫酷3D饼图(附完整源码) 本文详细介绍了如何使用ECharts创建炫酷的3D饼图,从环境配置到完整源码实现,涵盖参数解析、视觉优化和交互增强技巧。通过实战案例,帮助开发者快速掌握3D数据可视化技术,提升数据展示效果。 阅读详情

相关推荐

开源项目 ruoyi-sso-oauth2(一)环境配置

Ruoyi若依实现单点登录SSO、oauth2认证

Xiaoweidumpb 9685

[cpp进阶]C++智能指针

智能指针运用了RAII的思想。RAII(Resource Acquisition Is Initialization)是一种利用对象生命周期来控制程序资源(如内存、文件句柄、网络连接、互斥量等等)的简单技术。

weixin_53027918的博客 2025

从STM32转战华大HC32F4A0:我的踩坑实录与10个USART的灵活配置心得

本文分享了从STM32迁移至华大HC32F4A0的实战经验,重点解析了10个USART的灵活配置技巧及常见问题解决方案。通过对比STM32F407,详细介绍了HC32F4A0在外设灵活性、IO功能组设计及多串口应用中的优势,帮助开发者快速掌握国产芯片的开发要点。

weixin_30514745的博客 525

[cpp] 智能指针

cpp--智能指针详解

BinaryWiker的博客 1223

anaconda navigator 卡在loading application界面一直没有反应解决办法

在打开anaconda navigator 程序的时候,遇到了2个问题。第一个问题:打开的时候弹出提示:There is an instance of Anaconda Navigator already running.第二个问题:程序一直卡在loading application界面一直没有反应。以下是我的解决办法,有效果。

猿小白的博客 4387

《Python基础教程》内容总览篇(持续更新中)

大家好,我是爱编程的喵喵。双985硕士毕业,现担任全栈工程师一职,热衷于将数据思维应用到工作与生活中。从事机器学习以及相关的前后端开发工作。曾在阿里云、科大讯飞、CCF等比赛获得多次Top名次。现为优快云博客专家、人工智能领域优质创作者。喜欢通过博客创作的方式对所学的知识进行总结与归纳,不仅形成深入且独到的理解,而且能够帮助新手快速入门。个人精心开设的《Python基础课程》专栏订阅量接近900,帮助不少同学解决了Bug。

weixin_43178406的博客 35万+

CPP智能指针

4. 如果。

m0_55988098的博客 1208

C#与欧姆龙PLC 通信——Fins Tcp协议

该调试助手专门为了帮助大家学习以及测试Fins-Tcp通信,下面进行详细介绍。

qq_34059233的博客 2087

cpp智能指针

智能指针是c++中用于自动管理动态内存的类模板,通过RAII(资源获取即自动化)机制确保内存安全使用智能指针时要包含头文件<memory>unique_ptr独占所有权,同一时间只能有一个指针指向资源。当不希望对象的所有权被共享(即不希望多个指针同时指向同一个对象并可以修改它),unique_ptr是理想的选择。它强制了独占所有权,有助于避免因共享所有权带来的复杂的资源管理问题。用于管理单一资源,比如说局部对象、函数返回值等适合使用。

2401_88128034的博客 1244

7、PPG信号处理与质量评估

本文详细介绍了PPG信号的处理与质量评估方法,包括信号滤波技术(如卷积和互相关)、滤波器选择、信号质量指标(SQI)的定义与应用,以及标注一致性的评估。同时,提供了MATLAB代码示例和操作步骤,并分析了不同指标的优势与适用场景,旨在提高PPG信号在诊断和监测中的准确性与可靠性。

salt的博客 256

YOLOv11改进 | 注意力篇 | YOLOv11引入CA注意力机制

摘要:最近关于移动网络设计的研究已经证明了通道注意力(例如,挤压和激励注意力)对于提升模型性能的显着有效性,但它们通常忽略了位置信息,而位置信息对于生成空间选择性注意力图很重要。到此本文的正式分享内容就结束了,在这里给大家推荐我的YOLOv11改进有效涨点专栏,本专栏目前为新开的,后期我会根据各种前沿顶会进行论文复现,也会对一些老的改进机制进行补充,如果大家觉得本文帮助到你了,订阅本专栏,关注后续更多的更新~3.2 在Extramodule里创建CA。在CA.py文件里添加给出的CA代码。

tsg6698的博客 2981

cpp 智能指针

cpp 智能指针

ckg3824278的博客 1228

海思3516A移植MT7601U编译过程记录

官方地址:https://www.mediatek.com/products/broadbandWifi/mt7601 tar -xjf DPO_MT7601U_LinuxSTA_3.0.0.4_20130913.tar.bz2 cd DPO_MT7601U_LinuxSTA_3.0.0.4_20130913 1> Makefile替换 PLATFORM = HISI_3516A ifeq ($(PLATFORM),HISI_3516A) LINUX_SRC = /home/wbk/test/linu

qq_39048131的博客 1231

cpp自学 day26(智能指针)

摘要:本文详细解析C++11引入的智能指针机制,重点介绍三种核心类型:unique_ptr(独占所有权,支持移动语义)、shared_ptr(共享所有权,基于引用计数)和weak_ptr(非拥有性引用,解决循环引用问题)。智能指针通过RAII原则自动管理内存,有效防止内存泄漏和野指针。文章对比了make_unique/make_shared与传统new创建方式的优劣,提供典型使用场景示例,并列出各类型常用方法。特别强调使用注意事项,包括避免裸指针混用、循环引用风险等。通过智能指针可提升代码安全性和简洁性,是

CWNU_Dragon的博客 1306

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

C++ 智能指针

内存泄漏是指程序在动态分配内存后,未能正确释放这些内存,导致内存资源的浪费。随着时间的推移,未被释放的内存越来越多,最终可能导致系统资源耗尽。

azaz_plus的博客 1107

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

智能指针(cpp)

什么是内存泄漏:内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内 存泄漏并不是指内存在物理上的消失,而是应用程序分配某段内存后,因为设计错误,失去了对 该段内存的控制,因而造成了内存的浪费。内存泄漏的危害:长期运行的程序出现内存泄漏,影响很大,如操作系统、后台服务等等,出现 内存泄漏会导致响应越来越慢,最终卡死。// 1.内存申请了忘记释放// 2.异常安全问题Func();// 这里Func函数抛异常导致 delete[] p3未执行,p3没被释放.

z202331720425的博客 1105

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

Cherno的Cpp教程笔记022:C++的智能指针

智能指针

ResumeProject的博客 341

cpp智能指针的原理与使用

智能指针不是指针,是一个管理指针的类,用来存储指向动态分配对象的指针,负责自动释放动态分配的对象,防止堆内存泄漏和空悬指针等等问题。动态分配的资源,交给一个类对象去管理,当类对象声明周期结束时,自动调用析构函数释放资源。智能指针的历史历程:C++ 98 中产生了第一个智能指针auto_ptr。C++boost给出了更加实用的scoped_ptr(防止拷贝) 和 shared_ptr(引进引用计数) 和 weak_ptr。

菜一头包的博客 1216

【C++】智能指针

本篇文章围绕C++中的智能指针展开讲解,包含使用智能指针的原因、内存泄漏的概念、不同版本的智能指针的原理和使用等内容

Eristic0618的博客 1424

【C++11】智能指针

早期在C语言中我们学习了指针,这个指针学起来真是一个头两个大,当然学习到了这里想必大家对指针就不在害怕了,为了填上C++的不足在C++11中就扩展了智能指针,难道智能指针就真的那么智能吗?⭐主体。

AAlykk的博客 1300

CPP——智能指针

适用于需要独占资源的场景,自动管理内存,禁止拷贝,只能移动。:适用于资源需要被多个对象共享的场景,自动管理内存,使用引用计数,线程安全。:用于解决之间的循环引用问题,提供弱引用,不增加引用计数。通过合理使用这些智能指针,可以有效避免内存泄漏和悬挂指针等常见问题,使代码更加安全和易于维护。Valgrind 是一个内存调试工具,可以检测内存泄漏、未初始化的内存读取、越界访问等问题。

huiohuoi的博客 789

[C++] 智能指针 进阶

[C++] 智能指针 进阶 在很久之前我们探讨了智能指针的浅显认识,接下来会更加深入,从源码角度认识智能指针,从而了解智能指针的设计原理,并应用到以后的工作项目中。本文将会按照C++智能指针的发展历史,回顾智能指针的各个版本的设计。后半部分将会模拟实现最常考的shared_ptr的功能。

石墨博客 1253

C++基础智能指针

独占智能指针会“拥有”它所指向的对象,某一时刻,只能有一个unique_ptr指向给定的对象,当该指针被销毁时,指向的对象也会随之释放。shared_ptr共享他指向的对象,多个共享指针可以指向(关联)相同的对象,在内部采用计数器机制来实现当新的shared_ptr与对象关联时,引用计数器增加1当shared_ptr超出作用域时,引用计数器减1,当引用计数器变为0时,则表示没有任何shared_ptr与对象关联,则释放该对象​class Testpublic://名字。

没有百宝袋的哆啦A梦的博客 2060

C++之智能指针

C++智能指针介绍

2302_81120572的博客 875

C++智能指针的使用

1. 下面的程序中,new了以后,我们也delete了,但是因为抛异常导致后面的delete没有得到执行,所以就内存泄漏了,所以我们需要new以后捕获异常,捕获到异常后delete内存,再把异常抛出。,它是一种管理资源的类的设计思想,本质是一种利用对象生命周期来管理获取到的动态资源,避免资源泄漏,这里的资源可以是内存、文件指针、网络连接、互斥锁等等。4、weak_ptr弱(辅助解决shared_ptr的一个问题)指针,它不同于上面的指针,它不支持RAII,也就意味着不能用它直接管理资源,

的博客 1328
上一篇: C++类型转换
下一篇: C++的IO流
pythoncjavac++
博客等级 码龄5年 718粉丝 71原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

pythoncjavac++

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值