C++ 内存块 快速访问内存使用（一）

最新推荐文章于 2024-03-09 22:34:52 发布
最新推荐文章于 2024-03-09 22:34:52 发布
阅读量924 收藏
点赞数
分类专栏： C++ 文章标签： C++ 内存块 内存池 new delete
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xnayufenglin/article/details/40658915
版权


    这里要说的内存块就是预先申请一块内存，然后在这块内存上快速申请固定长度的内存，还达不到内存池的功能，但可以用来做内存池，下面是代码实现，同时加了一些注释，足够解释清楚了，内部使用模板的功能，增加可适应性

    先说说下这个内存块的原理吧，首先分配出一块内存，假设这块内存要分配出n个等大小的node，初始状态下第一个node会记录第二个node的地址，第二个记录第三个的，以此类推形成一个链表，这样就是对链表进行操作了，需要注意的是由于一个node需要记录另一个node的地址，所以node的大小必须大于一个指针的大小，在这个内存块中通过枚举做了这个工作，分配和回收函数通过对链表的操作来进行工作，简单验证了下，功能正常，要是大量申请和销毁内存速度相当可以，可以拿来做内存池使用

    同时我还用另一种方式实现了内存块，效率也相当高，C++ 内存块 快速访问内存使用（二），不知道这里面是否还有没有考虑清楚的bug，希望牛人看完后给个评论 微笑

  


/* 
============================================================================================
	内存块 非线程安全
	原理：
	每个未使用的node记录某个未使用的node的位置 形成一个链表
	要求元素的大小必须大于等于一个指针的大小 内部会自动调剂这个大小
	每次操作都要充分考虑没有分配的内存
	调用Malloc需要调用Free销毁  调用New需要调用Delete来销毁
	使用New或者Delete函数 存在一些类型构造和析构的回调 不要在析构的回调中调用无参的Delete
	在无参的Delete防止析构回调再次使用内存块分配和释放 做了一些处理
	使用TRACE_MEM_BLOCK可以开启内存块一些信息的追踪

	add 2013.11.22 by yuwf

	Copyright (c), ...	

=============================================================================================
*/

#ifndef _PALANTIR_MEM_BLOCK_H
#define _PALANTIR_MEM_BLOCK_H

#include "PLTTrace.h"

namespace Palantir
{

#ifdef PALANTIR_TRACE
#ifndef TRACE_MEM_BLOCK
#define TRACE_MEM_BLOCK
#endif
#endif

	// 每个未使用的node记录某个未使用的node的位置 故而NODE_SIZE必须大于一个指针的大小
	template<unsigned int _NODE_SIZE_, unsigned int _NODE_COUNT_ = 8>
	struct MemBlock
	{
		enum
		{
			NODE_SIZE	= _NODE_SIZE_ >= sizeof(void*) ? _NODE_SIZE_ : sizeof(void*),	// node的大小 最小是一个指针的大小
			NODE_COUNT	= _NODE_COUNT_ == 0 ? 8 : _NODE_COUNT_,							// node的个数
			TRACE_SIZE	= NODE_SIZE*2,													// 用两个node的大小跟踪
		};

		MemBlock();
		~MemBlock();

		// 分配一块内存
		inline void* Malloc();

		// p 必须是从这个block上malloc获取的
		// 返回值表示删除成功 
		inline bool Free( const void* p );

		// 把分配的全部回收到内存块中
		inline void Free();


		// 基于类型的函数
		template<class T>
		T* New()
		{
			return ::new(Malloc()) T();
		}

		template<class T, class T1>
		T* New( const T1& param1 )
		{
			return ::new(Malloc()) T( param1 );
		}

		template<class T, class T1, class T2, class T3>
		T* New( const T1& param1, const T2& param2, const T3& param3 )
		{
			return ::new(Malloc()) T( param1, param2, param3 );
		}

		template<class T, class T1, class T2, class T3, class T4>
		T* New( const T1& param1, const T2& param2, const T3& param3, const T4& param4 )
		{
			return ::new(Malloc()) T( param1, param2, param3, param4 );
		}

		template<class T, class T1, class T2, class T3, class T4, class T5>
		T* New( const T1& param1, const T2& param2, const T3& param3, const T4& param4, const T5& param5 )
		{
			return ::new(Malloc()) T( param1, param2, param3, param4, param5 );
		}

		template<class T, class T1, class T2, class T3, class T4, class T5, class T6>
		T* New( const T1& param1, const T2& param2, const T3& param3, const T4& param4, const T5& param5, const T6& param6 )
		{
			return ::new(Malloc()) T( param1, param2, param3, param4, param5, param6 );
		}

		template<class T, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
		T* New( const T1& param1, const T2& param2, const T3& param3, const T4& param4, const T5& param5, const T6& param6, const T7& param7 )
		{
			return ::new(Malloc()) T( param1, param2, param3, param4, param5, param6, param7 );
		}

		template<class T, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
		T* New( const T1& param1, const T2& param2, const T3& param3, const T4& param4, const T5& param5, const T6& param6, const T7& param7, const T8& param8 )
		{
			return ::new(Malloc()) T( param1, param2, param3, param4, param5, param6, param7, param8 );
		}

		template<class T, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
		T* New( const T1& param1, const T2& param2, const T3& param3, const T4& param4, const T5& param5, const T6& param6, const T7& param7, const T8& param8, const T9& param9 )
		{
			return ::new(Malloc()) T( param1, param2, param3, param4, param5, param6, param7, param8, param9 );
		}

		// p是T类型 会调用 p->~T()
		template<class T>
		inline bool Delete( const void* p );

		// 把分配的全部回收到内存块中
		template<class T>
		inline void Delete();

		// 判断指针是否是这个block上的
		inline bool Is_From(const void* p ) const;

		// 已使用的数量
		inline unsigned int Used_Count() const { return NODE_COUNT - free_num; };

		// 未使用的数量
		inline unsigned int Free_Count() const { return free_num; };

		// 是否分配完毕
		inline bool Is_Full() const { return free_num == 0 ; }

		// 是否未使用
		inline bool Is_Not_Use() const { return free_num == NODE_COUNT; }

	protected:
		// 没必要支持拷贝
		MemBlock( const MemBlock& ) {};
		MemBlock& operator = ( const MemBlock& ) { return *this; };

#pragma pack(1) //设置1字节对齐
		// 表示一个node
		struct free_node
		{
			char buffer[NODE_SIZE];				// 一个node占据的大小

			void setnext( free_node* pnext )
			{
				if ( pnext == nullptr )
					memset( buffer, 0, sizeof(free_node*) );
				else
					memcpy( buffer, &pnext, sizeof(free_node*) );
			}

			free_node* getnext()
			{
				free_node* p = nullptr;
				memcpy( &p, &buffer[0], sizeof(free_node*) );
				return p;
			}
		};
#pragma pack() //取消设置的字节对齐方式

		unsigned int free_num;		// 未分配的个数 用户快速判断是否还有空间
		free_node* cur_free_node;	// 当前空的node
		free_node buffer[NODE_COUNT];	// 所有的node

#ifdef TRACE_MEM_BLOCK
		unsigned char tracemem[TRACE_SIZE];		// 用来追踪这个块是否写超了
		static unsigned char tracememflag[TRACE_SIZE];
#endif

	};

// ================ 实现部分 =====================

#ifdef TRACE_MEM_BLOCK
	template<unsigned int _NODE_SIZE_, unsigned int _NODE_COUNT_>
	unsigned char MemBlock<_NODE_SIZE_,_NODE_COUNT_>::tracememflag[MemBlock<_NODE_SIZE_,_NODE_COUNT_>::TRACE_SIZE];
#endif

	template<unsigned int _NODE_SIZE_, unsigned int _NODE_COUNT_>
	MemBlock<_NODE_SIZE_,_NODE_COUNT_>::MemBlock() : free_num(NODE_COUNT), cur_free_node(&buffer[0])
	{
		for ( int i = 1; i < NODE_COUNT; ++i )
		{
			buffer[i-1].setnext( &buffer[i] );
		}
		buffer[NODE_COUNT-1].setnext( nullptr );
#ifdef TRACE_MEM_BLOCK
		memcpy( tracemem, tracememflag, sizeof(tracemem) );
#endif
	}

	template<unsigned int _NODE_SIZE_, unsigned int _NODE_COUNT_>
	MemBlock<_NODE_SIZE_,_NODE_COUNT_>::~MemBlock()
	{
#ifdef TRACE_MEM_BLOCK
		// 用位记录是否分配出去 0标示分配出去了 1标示未分配
		char freenodes[ (NODE_COUNT%8 == 0 ? NODE_COUNT : NODE_COUNT+(8-NODE_COUNT%8))/8 ] = {0};
		free_node* cur_node = cur_free_node;
		while ( cur_node )
		{
			int index = ((uintptr_t)cur_node - (uintptr_t)&buffer[0])/sizeof(free_node);
			freenodes[index/8] |= 1 << (7-index%8);
			cur_node = cur_node->getnext();
		}
		// 调用析构函数
		for ( int i = 0; i < NODE_COUNT; ++i )
		{
			if ( !(freenodes[i/8] & ( 1 << (7-i%8) ) ) )
			{
				PLT_Trace( "%s 分配出去的内存没有收回 %p\n", __FUNCTION__, &buffer[i] );
			}
		}
		if ( memcmp( tracemem, tracememflag, sizeof(tracemem) ) != 0 )
		{
			PLT_Trace( "%s 内存块写超了\n", __FUNCTION__ );
		}
#endif
	}

	template<unsigned int _NODE_SIZE_, unsigned int _NODE_COUNT_>
	inline void* MemBlock<_NODE_SIZE_,_NODE_COUNT_>::Malloc()
	{
		if ( cur_free_node == nullptr )
		{
			return nullptr;
		}
		void* pnode = cur_free_node;
		cur_free_node = cur_free_node->getnext();
		--free_num;
		return pnode;
	}
	
	template<unsigned int _NODE_SIZE_, unsigned int _NODE_COUNT_>
	inline bool MemBlock<_NODE_SIZE_,_NODE_COUNT_>::Free( const void* p )
	{
		if ( free_num == NODE_COUNT )
		{
#ifdef TRACE_MEM_BLOCK
			PLT_Trace( "%s 内存块没有往外分配任何元素\n", __FUNCTION__ );
#endif
			return false;
		}
		if ( (uintptr_t)p < (uintptr_t)&buffer[0] || (uintptr_t)p > (uintptr_t)&buffer[NODE_COUNT-1] )
		{
#ifdef TRACE_MEM_BLOCK
			PLT_Trace( "%s 指针并不是block分配出去的 buffer.begin=%p, buffer.end=%p p=%p\n", __FUNCTION__, &buffer[0], &buffer[NODE_COUNT-1], p );
#endif
			return false;
		}
		if( ((uintptr_t)p - (uintptr_t)&buffer[0])%sizeof(free_node) != 0 )
		{
#ifdef TRACE_MEM_BLOCK
			PLT_Trace( "%s 指针存在这个block上，但不在一个分配的位置 buffer.begin=%p, buffer.end=%p p=%p\n", __FUNCTION__, &buffer[0], &buffer[NODE_COUNT-1], p );
#endif
			return false;
		}

		free_node* cur_node = cur_free_node;
		while ( cur_node )
		{
			if ( cur_node == p )
			{
#ifdef TRACE_MEM_BLOCK
				PLT_Trace( "%s 指针存在这个block上，但这个位置并没有分配出去 buffer.begin=%p, buffer.end=%p p=%p\n", __FUNCTION__, &buffer[0], &buffer[NODE_COUNT-1], p );
#endif
				return false;
			}
			cur_node = cur_node->getnext();
		}

#ifdef TRACE_MEM_BLOCK
		if ( memcmp( tracemem, tracememflag, sizeof(tracemem) ) != 0 )
		{
			PLT_Trace( "%s 内存块写超了\n", __FUNCTION__ );
		}
#endif

		free_node* pnode = (free_node*)p;
		pnode->setnext( cur_free_node );
		cur_free_node = pnode;
		++free_num;
		return true;
	}

	template<unsigned int _NODE_SIZE_, unsigned int _NODE_COUNT_>
	inline void MemBlock<_NODE_SIZE_,_NODE_COUNT_>::Free()
	{
		if ( free_num == NODE_COUNT )
		{
			return;
		}
#ifdef TRACE_MEM_BLOCK
		if ( memcmp( tracemem, tracememflag, sizeof(tracemem) ) != 0 )
		{
			PLT_Trace( "%s 内存块写超了\n", __FUNCTION__ );
		}
#endif
		for ( int i = 1; i < NODE_COUNT; ++i )
		{
			buffer[i-1].setnext( &buffer[i] );
		}
		buffer[NODE_COUNT-1].setnext( nullptr );
		cur_free_node = &buffer[0];
		free_num = NODE_COUNT;
	}

	template<unsigned int _NODE_SIZE_, unsigned int _NODE_COUNT_>
	template<class T>
	inline bool MemBlock<_NODE_SIZE_,_NODE_COUNT_>::Delete( const void* p )
	{
		if ( free_num == NODE_COUNT )
		{
#ifdef TRACE_MEM_BLOCK
			PLT_Trace( "%s 内存块没有分配任何元素\n", __FUNCTION__ );
#endif
			return false;
		}
		if ( (uintptr_t)p < (uintptr_t)&buffer[0] || (uintptr_t)p > (uintptr_t)&buffer[NODE_COUNT-1] )
		{
#ifdef TRACE_MEM_BLOCK
			PLT_Trace( "%s 指针并不是block分配出去的 buffer.begin=%p, buffer.end=%p p=%p\n", __FUNCTION__, &buffer[0], &buffer[NODE_COUNT-1], p );
#endif
			return false;
		}
		if( ((uintptr_t)p - (uintptr_t)&buffer[0])%sizeof(free_node) != 0 )
		{
#ifdef TRACE_MEM_BLOCK
			PLT_Trace( "%s 指针存在这个block上，但不在一个分配的位置 buffer.begin=%p, buffer.end=%p p=%p\n", __FUNCTION__, &buffer[0], &buffer[NODE_COUNT-1], p );
#endif
			return false;
		}
		free_node* cur_node = cur_free_node;
		while ( cur_node )
		{
			if ( cur_node == p )
			{
#ifdef TRACE_MEM_BLOCK
				PLT_Trace( "%s 指针存在这个block上，但这个位置并没有分配出去 buffer.begin=%p, buffer.end=%p p=%p\n", __FUNCTION__, &buffer[0], &buffer[NODE_COUNT-1], p );
#endif
				return false;
			}
			cur_node = cur_node->getnext();
		}
#ifdef TRACE_MEM_BLOCK
		if ( memcmp( tracemem, tracememflag, sizeof(tracemem) ) != 0 )
		{
			PLT_Trace( "%s 内存块写超了\n", __FUNCTION__ );
		}
#endif
		
		T* pobj = (T*)p;
		pobj->~T();	// 这里相当于有回调 可能会存在在回调中调用同一个内存块创建和删除node 
					// 其实没关系 只要在这个回调中不重复删除自己(pobj)（若在析构函数中在删除自己 系统提供的delete也会崩掉） 就不会存在任何问题 
					// 因为本函数中只有下面的代码会修改这个内存块的变量
					// 若在析构回调中调用无参的Delete，则会出现重复调用~T()的情况

		if ( free_num == NODE_COUNT )	// 防止在析构回调中调用了那个无参的Delete
		{
#ifdef TRACE_MEM_BLOCK
			PLT_Trace( "%s 出现了不可预知的错误\n", __FUNCTION__ );
#endif
			return false;
		}

		free_node* pnode = (free_node*)p;
		pnode->setnext( cur_free_node );
		cur_free_node = pnode;
		++free_num;
		return true;
	}

	template<unsigned int _NODE_SIZE_, unsigned int _NODE_COUNT_>
	template<class T>
	inline void MemBlock<_NODE_SIZE_,_NODE_COUNT_>::Delete()
	{
		if ( free_num == NODE_COUNT )
		{
			return;
		}

#ifdef TRACE_MEM_BLOCK
		if ( memcmp( tracemem, tracememflag, sizeof(tracemem) ) != 0 )
		{
			PLT_Trace( "%s 内存块写超了\n", __FUNCTION__ );
		}
#endif
		// 用位记录是否分配出去 0标示分配出去了 1标示未分配
		char freenodes[ (NODE_COUNT%8 == 0 ? NODE_COUNT : NODE_COUNT+(8-NODE_COUNT%8))/8 ] = {0};
		free_node* cur_node = cur_free_node;
		// 首先修改下面两个值 防止下面的析构函数再次使用内存块分配和释放node
		cur_free_node = nullptr;
		free_num = NODE_COUNT;

		while ( cur_node )
		{
			int index = ((uintptr_t)cur_node - (uintptr_t)&buffer[0])/sizeof(free_node);
			freenodes[index/8] |= 1 << (7-index%8);
			cur_node = cur_node->getnext();
		}
		// 调用析构函数
		for ( int i = 0; i < NODE_COUNT; ++i )
		{
			if ( !(freenodes[i/8] & ( 1 << (7-i%8) ) ) )
			{
				T* pobj = (T*)(&buffer[i]);
				pobj->~T();
			}
		}
		// 复位
		for ( int i = 1; i < NODE_COUNT; ++i )
		{
			buffer[i-1].setnext( &buffer[i] );
		}
		buffer[NODE_COUNT-1].setnext( nullptr );
		cur_free_node = &buffer[0];
		free_num = NODE_COUNT;
	}

	template<unsigned int _NODE_SIZE_, unsigned int _NODE_COUNT_>
	inline bool MemBlock<_NODE_SIZE_,_NODE_COUNT_>::Is_From( const void* p ) const
	{
		if ( (uintptr_t)p < (uintptr_t)&buffer[0] || (uintptr_t)p > (uintptr_t)&buffer[NODE_COUNT-1] )
		{
			return false;
		}
		if( ((uintptr_t)p - (uintptr_t)&buffer[0])%sizeof(free_node) != 0 )
		{
#ifdef TRACE_MEM_BLOCK
			PLT_Trace( "%s 指针存在这个block上，但不在一个分配的位置 buffer.begin=%p, buffer.end=%p p=%p\n", __FUNCTION__, &buffer[0], &buffer[NODE_COUNT-1], p );
#endif
			return false;
		}
		if ( free_num == NODE_COUNT )
		{
#ifdef TRACE_MEM_BLOCK
			PLT_Trace( "%s 内存块没有往外分配任何元素\n", __FUNCTION__ );
#endif
			return false;
		}
		free_node* cur_node = cur_free_node;
		while ( cur_node )
		{
			if ( cur_node == p )
			{
#ifdef TRACE_MEM_BLOCK
				PLT_Trace( "%s 指针存在这个block上，但这个位置并没有分配出去 buffer.begin=%p, buffer.end=%p p=%p\n", __FUNCTION__, &buffer[0], &buffer[NODE_COUNT-1], p );
#endif
				return false;
			}
			cur_node = cur_node->getnext();
		}
#ifdef TRACE_MEM_BLOCK
		if ( memcmp( tracemem, tracememflag, sizeof(tracemem) ) != 0 )
		{
			PLT_Trace( "%s 内存块写超了\n", __FUNCTION__ );
		}
#endif
		return true;
	}

}

#endif



xnayufenglin
关注
专栏目录
C++代码基本内存操作及原理
新兴IT民工的专栏
12-02 1235
C++内存使用的基本逻辑
为什么选择C/C++内存检测工具AddressSanitizer？如何使用AddressSanitizer？
热门推荐
dvlinker的技术专栏
09-13 2万+
为什么选择C/C++内存检测工具AddressSanitizer？如何使用AddressSanitizer？
C++ 内存块 快速访问内存使用（二）
于文锋的专栏
11-03 694
注： 这些代码是去年就
C/C++ 内存块与字符串操作函数
aiyifan1314的专栏
07-05 1004
一、 内存块操作： 1. 将dest前面count个字符置为字符c，返回dest的值 void* memset( void *dest，int c，size_t count ); 2. 从src复制count字节的字符到dest，返回dest的值。     如果src和dest出现重叠，函数会自动处理。 void* memmove(void *dest，const void
内存分配详解
什么windows,linux,Mac OS
01-24 791
<br />内存分配方式 <br /><br />   （1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。<br />   （2）在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。<br />   （3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负
关于C&C++内存访问
zhb9103的专栏
11-21 396
1.内存数据存取:例如:要读和写内存单元为0X10000的数据;char *p=(char *)0x10000读:printf("%d",*p);写:*p=10;2.执行固定在0x10000处的一段程序;1) void (*p)(void)=(void (*)(void))0x10000;执行:    p();2) (*(void (*)())0x10000)();3) 关于如何将一个函数写入0x10000就还不清楚,问题是找不到函数的长度或函数的结束符号.
内存虚拟硬盘C++源码
04-26
3. **缓冲区管理**：为了优化性能，内存虚拟硬盘可能会使用缓冲区来减少对内存的直接访问。这需要理解缓冲区的概念以及如何在内存中高效地管理和刷新缓冲区。 4. **数据持久化**：由于内存是易失性的，当系统重启或...
巧用Visual Studio中的数据断点去排查C++内存越界问题
dvlinker的技术专栏
07-06 1万+
本文详细介绍如何使用Visual Studio中的数据断点去排查C++软件中的内存越界问题。
一个C++内存池实现
12-13
内存池是一种优化内存分配策略的技术，它在程序启动时预先分配一大块连续的内存，并将这些内存分割成多个固定大小的块，供后续的内存申请使用。这种方式避免了频繁的系统调用，减少了内存碎片，提高了内存分配和释放...
共享内存通讯,共享内存通讯源码,C,C++
09-11
共享内存是一种在多进程间通信的有效方式，尤其在并发编程中，它允许不同的进程访问同一块内存区域，从而实现数据的快速交换。标题提到的"共享内存通讯,共享内存通讯源码,C,C++"，表明我们将探讨的是如何使用C和C++...
显示CPU和内存占用情况C++源码
12-01
图表显示当前CPU和内存占用情况，含完整源码和可执行程序
C/C++语言对内存的使用
qq_25815379的博客
06-11 327
C和C++的编译器，把私有内存分为3块，基栈、浮动栈和堆。如图： 1、基栈：也叫静态存储区。这是编译器在编译期间。就已经固定下来必须要使用的内存，如程序的代码段，静态变量，全局变量，const常量等。程序一调入内存，至少就要占用这么多空间。有个简单的不太准确的算法，exe文件有多大，差不多基栈就有多大。 2、浮动栈：很多书上，就叫“栈”，就是程序开始运行，随着函数，对象的一段段执行，函数内...
C++程序中内存使用情况简析
letsgowei的专栏
03-14 630
一、预备知识—程序的内存分配     一个由C/C++编译的程序占用的内存分为以下几个部分 ：   1、栈区（stack）—   由编译器自动分配释放   ，存放函数的参数值，局部变量的值等。其     操作方式类似于数据结构中的栈。     2、堆区（heap）   —   一般由程序员分配释放，   若程序员不释放，程序结束时可能由OS回     收   。注意它与数据结构中的堆是两
C++动态内存使用
hjhomw的博客
08-22 705
在C++中，直接对动态内存的管理是通过运算符new和delete来完成的。 new：在动态内存中为对象分配空间并返回一个指向该对象的指针。 delete: 接受一个动态对象的指针，销毁该对象，并释放与之关联的内存。 一、使用new动态分配和初始化对象的几种方式：1. 默认情况下，动态分配的对象是默认初始化的，故内置类型或组合类型的对象的值是未定义的，类类型对象将用默认构造函数进行初始化int *pi
C/C++内存函数的用法及其实现（ 超详细）
敲代码嘞~的博客
10-05 1457
而对于内存中的数据，我们在写函数的时候并不知道程序员将调用这个函数来完成什么类型的数据拷贝，如果将它强转成（int*）类型的话，在需要复制的数据所占空间不是4的整数的时候在边界会一些问题。我们需要知道void*类型的指针不能直接进行解引用操作和运算操作，需要把它进行强制类型转化为所适合的类型，然后再进行相应的操作。destination：指向要在其中复制内容的目标数组的指针，类型转换为 void* 类型的指针。source：指向要复制的数据源的指针，类型转换为 const void* 类型的指针。
C/C++内存操作
liupeng_csdn的博客
11-22 1097
C/C++内存操作 内存操作的三种方法 一.从静态存储区分配 从静态存储区域分配。是指内存在程序编译的时候就已经分配好，这块内存在程序的整 个运行期间都存在。例如全局变量，static 变量。（未初始化的内存分配在bss区，初始化的在数据区） 二.在栈上创建 在栈上创建内存。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函 数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集（栈区） 中，效率很高，但是分配的内存容量有限。 三.从堆区分配 从堆上分配，亦称动态内存分配。程序在运行
C++内存管理篇
最新发布
2303_77982246的博客
03-09 1173
在某些场景下，我们向内存申请的空间没有初始化，比如向内存池申请的空间，如果是自定义类型的对象，我们可以使用new的定义表达式进行显示调用构造函数进行初始化。C++中，这些函数依然可用，但在使用上是比较麻烦的；C++语言中，我们用malloc/calloc/realloc/free函数进行内存的开辟和释放，对内存进行管理。可以看到，new和delete的最底层还是使用的malloc和free函数，只不过是对它进行了一系列封装。C语言中，为了方便管理内存空间，将内存分成了不同的区域，每个区域管理不同的数据。
C++实现简单的内存块自动管理
weeks
07-26 1288
#ifndef __MEM__H #define __MEM__H #include using namespace std; //自动管理内存块 typedef unsigned char byte; class Mem { private: byte* mem; int size; void ensureMinSize(int minSize); public: Mem();
深入详解C/C++动态内存管理
dvlinker的技术专栏
07-19 1万+
本文详细讲述了C/C++动态内存管理方面的内容，并具体阐述了几类常见的动态内存异常，以供大家借鉴或参考！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值