C语言之内存动态管理(边界标识法)源码

最新推荐文章于 2024-04-16 07:30:44 发布
最新推荐文章于 2024-04-16 07:30:44 发布
阅读量987 收藏 4
点赞数
分类专栏： 开源计划 文章标签： 动态内存管理 边界标识法 源码 c/c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/freeland008/article/details/107302975
版权

 

1       概述.... 3

2       背景.... 3

3       工作机制.... 3

4       分配机制特点.... 3

5       应用场景.... 3

6       源码文件.... 4

6.1       MemAlloc.h. 4

6.2       MemAlloc.cpp. 4

7       数组接口函数使用说明.... 16

7.1       CreateHeap(). 16

7.2       DestroyHeap (). 17

7.3       AllocMem(). 17

7.4       FreeMem(). 18

8       demo.. 19

 

  1.  概述

本文讲述一种的内存动态管理机制：边界标识法。关于边界标识法大家有兴趣的话可以阅读清华计算机教材《数据结构》(作者：严蔚敏、吴伟民)第八章(动态存储管理)中第3节(边界标识法)。本文主要是针对从事后台服务器程序领域讲述这种内存分配机制的应用场景和优缺点。

 

2.背景

本文提出的内存分配管理策略是对清华计算机教材《数据结构》(作者：严蔚敏、吴伟民)第八章(动态存储管理)中第3节(边界标识法)示例代码的整理和封装。

 

3. 工作机制

应用程序首先调用mallo()函数预先分配出一块内存空间，然后在这个内存空间中使用边界标识法分配出应用程序需要的内存，内存释放时，会自动合并前后紧邻的空闲块，形成更大的空闲块。

 

4. 分配机制特点

该机制优点是：

  1. 可以根据需要分配任意大小的空间，不需要取整。
  2. 释放内存操作极快。

 

该机制缺点是：

1、长时间运行可能会产生大量碎片，导致内存分配的效率降低和内存的浪费。

 

  1.  应用场景

针对服务器程序应用场景：

1、需要连续内存空间。

2、分配内存大小范围大，从1个字节到上兆、几十兆。

3、分配的空间只是临时使用，用完就释放，不至于产生大量碎片。

另外：如果设计的软件对性能要求不高，也可以考虑使用此种内存分配机制。

 

5. 源码文件

 

5.1 MemAlloc.h

 


#ifndef MEMALLOC_H
#define MEMALLOC_H

typedef void* HANDLE;

HANDLE CreateHeap(int nHeapSize);
void DestroyHeap(HANDLE hHeap);
void* AllocMem(HANDLE hHeap, int nSize);
void FreeMem(HANDLE hHeap, void* pAddr);
int GetAddrSize(void* pAddr);
void FreeAllMem(HANDLE hHeap);

#endif

 

5.2  MemAlloc.cpp

 

#include "MemAlloc.h"
#include "TagShare.h"
#include <stdio.h>

static AllocTail* FootLoc(AllocNode* pHead)
{	
	return (AllocTail *)((char *)pHead + pHead->nSize - sizeof(AllocTail));
}

int GetSelfUplink(AllocNode* p)
{
	return ((AllocTail *)((char *)p + p->nSize - sizeof(AllocTail)))->nUpLink;
}

static AllocNode* GetLeftNode(HeapInfo* pHeapInfo, AllocNode* p)
{
	return (AllocNode*)(pHeapInfo->pBuf + ((AllocTail *)((char *)p - sizeof(AllocTail)))->nUpLink);
}

HANDLE CreateHeap(int nHeapSize)
{	
	HeapInfo* pHeapInfo;
	pHeapInfo = (HeapInfo*)(new char[sizeof(HeapInfo) + nHeapSize + SHELL_SIZE]);	
	if(pHeapInfo == NULL)
	{
		return NULL;
	}
	pHeapInfo->nHeapSize = nHeapSize + SHELL_SIZE;	
	
	pHeapInfo->nCount = 1;
	pHeapInfo->pHead = (AllocNode *)pHeapInfo->pBuf;
	pHeapInfo->pTail = (AllocNode *)pHeapInfo->pBuf;		

	AllocNode* pNode;
	pNode = pHeapInfo->pHead;	
	
	pNode->nLeftLink = -1;
	pNode->nTag = 0;
	pNode->nSize = pHeapInfo->nHeapSize;
	pNode->nRightLink = -1;

	AllocTail* pTail;
	pTail = FootLoc(pNode);	
	pTail->nUpLink = 0;
	pTail->nTag = 0;

	return pHeapInfo;
}

void DestroyHeap(HANDLE hHeap)
{
	HeapInfo* pHeapInfo;
	pHeapInfo = (HeapInfo *)hHeap;		

	if(pHeapInfo != NULL)
	{
		delete[] (char *)pHeapInfo;
		pHeapInfo = NULL;
	}	
	
	return;
}

static void RemoveHead(HeapInfo* pHeapInfo)
{	
	pHeapInfo->nCount--;		
	
	if(pHeapInfo->pHead->nRightLink == -1)
	{
		pHeapInfo->pHead = NULL;
	}
	else
	{
		pHeapInfo->pHead = (AllocNode *)(pHeapInfo->pBuf + pHeapInfo->pHead->nRightLink);
	}	

	if(pHeapInfo->pHead != NULL)
	{	
		pHeapInfo->pHead->nLeftLink = -1;
		if(pHeapInfo->nCount == 1)
		{
			pHeapInfo->pHead->nRightLink = -1;	
		}
	}
	else
	{			
		pHeapInfo->pTail = NULL;
	}		
	
	return;
}

static void RemoveTail(HeapInfo* pHeapInfo)
{					
	pHeapInfo->nCount--;
	
	if(pHeapInfo->pTail->nLeftLink == -1)
	{
		pHeapInfo->pTail = NULL;
	}
	else
	{
		pHeapInfo->pTail = (AllocNode *)(pHeapInfo->pBuf + pHeapInfo->pTail->nLeftLink);
	}
	
	if(pHeapInfo->pTail != NULL)
	{	
		pHeapInfo->pTail->nRightLink = -1;
		if(pHeapInfo->nCount == 1)
		{
			pHeapInfo->pHead->nLeftLink = -1;
		}
	}
	else
	{			
		pHeapInfo->pHead = NULL;
	}		
	
	return;
}

static void RemoveAt(HeapInfo* pHeapInfo, AllocNode* pNode)
{	
	if(pNode == pHeapInfo->pHead)
	{
		RemoveHead(pHeapInfo);
		return;
	}
	
	if(pNode == pHeapInfo->pTail)
	{
		RemoveTail(pHeapInfo);
		return;
	}	
	
	AllocNode* pPrev;
	AllocNode* pNext;	
	
	if(pNode->nLeftLink == -1)
	{
		pPrev = NULL;
	}
	else
	{
		pPrev = (AllocNode *)(pHeapInfo->pBuf + pNode->nLeftLink);
	}
	
	if(pNode->nRightLink == -1)
	{
		pNext = NULL;
	}
	else
	{
		pNext = (AllocNode *)(pHeapInfo->pBuf + pNode->nRightLink);		
	}	
	
	if(pNext == NULL)
	{
		pPrev->nRightLink = -1;
	}
	else
	{
		if(pPrev != NULL)
		{
			pPrev->nRightLink = GetSelfUplink(pNext);
		}		
	}
	
	if(pPrev == NULL)
	{
		pNext->nLeftLink = -1;
	}
	else
	{
		if(pNext != NULL)
		{
			pNext->nLeftLink = GetSelfUplink(pPrev);
		}		
	}	
	
	pHeapInfo->nCount--;
	
	return;
}

void* AllocMem(HANDLE hHeap, int nSize)
{
	HeapInfo* pHeapInfo;
	pHeapInfo = (HeapInfo *)hHeap;

	if(pHeapInfo->nCount == 0)
	{
		return NULL;
	}

	nSize += SHELL_SIZE;

	AllocNode* p;	
	p = pHeapInfo->pHead;
	while(true)
	{
		if(p->nSize < nSize)
		{	// 不符合条件
			if(p->nRightLink < 0)
			{	// 循环链表构成循环
				return NULL;
			}		
			p = (AllocNode *)(pHeapInfo->pBuf + p->nRightLink);						
		}	
		else
		{	// 满足条件				
			if(p->nSize - nSize <= MINI)
			{	// 把整个空闲块进行整体分配
				AllocTail* pFoot;
				pFoot = FootLoc(p);		// 取尾巴结构
				
				p->nExtraSize = p->nSize - nSize;
				p->nTag = 1;					// 设置头占用标志
				pFoot->nTag = 1;		// 设置尾占用标志					
				
				RemoveAt(pHeapInfo, p);
				return p+1;			
			}
			else
			{
				AllocTail* pOldFreeFoot;
				pOldFreeFoot = FootLoc(p);		// 取尾巴结构

				pOldFreeFoot->nTag = 1;		// 设置占用块尾巴标记（tag）：1(占用)				
				p->nSize -= nSize;	// 设置新空闲块头size: 
			
				AllocTail* pNewFreeFoot;
				pNewFreeFoot = FootLoc(p); // 获取新空闲块的foot
				pNewFreeFoot->nTag = 0;		// 设置新空闲块尾巴标记（tag）：0(空闲)
				pNewFreeFoot->nUpLink = pOldFreeFoot->nUpLink;	// 设置新空闲块的uplink				

				pOldFreeFoot->nUpLink = pNewFreeFoot->nUpLink + p->nSize;

				AllocNode* pBusyHead;
				pBusyHead = (AllocNode*)((char *)pNewFreeFoot + sizeof(AllocTail));	
				pBusyHead->nExtraSize = 0;
				pBusyHead->nTag = 1;		// p为占用块的头的标记
				pBusyHead->nSize = nSize;	// 	p为占用块的头的的size
				pBusyHead++;
				return pBusyHead;
			}			
		}
	}
}

// 左：忙 右：忙
static void FreeMem1(HeapInfo* pHeapInfo, AllocNode* p)
{
	p->nTag = 0;

	AllocTail* pFoot;
	pFoot = FootLoc(p);	
	pFoot->nTag = 0;

	if(pHeapInfo->nCount == 0)
	{		
		p->nRightLink = -1;
		p->nLeftLink = -1;
		pHeapInfo->pHead = p;
		pHeapInfo->pTail = p;
		pHeapInfo->nCount = 1;
	}
	else
	{			
		pHeapInfo->pTail->nRightLink = GetSelfUplink(p);
		p->nLeftLink = GetSelfUplink(pHeapInfo->pTail);
		p->nRightLink = -1;
		pHeapInfo->pTail = p;
		pHeapInfo->nCount++;			
	}
}

// 左：闲 右：忙
static void FreeMem2(HeapInfo* pHeapInfo, AllocNode* p)
{
	int n;
	n = p->nSize;
	
	AllocNode* pLeftNode;
	pLeftNode = GetLeftNode(pHeapInfo, p);

	int nUplink;
	nUplink = GetSelfUplink(pLeftNode);

	pLeftNode->nSize += n;

	AllocTail* pFoot;
	pFoot = FootLoc(p);
	pFoot->nUpLink = nUplink;
	pFoot->nTag = 0;	

	return;
}

// 左：忙 右：闲
static void FreeMem3(HeapInfo* pHeapInfo, AllocNode* p)
{
	AllocNode* pRightNode;		// 右邻空闲区的头
	pRightNode = (AllocNode *)((char *)p + p->nSize);	// 获取右邻空闲区的头
	p->nTag = 0;			// p为合并后的节点头部

	int nUpLink;
	nUpLink = GetSelfUplink(p);

	int nRightFreeSize;
	nRightFreeSize = pRightNode->nSize;

	RemoveAt(pHeapInfo, pRightNode);	

	p->nSize += nRightFreeSize;	
	FootLoc(p)->nUpLink = nUpLink;
	///增加一个空闲块//
	if(pHeapInfo->nCount == 0)
	{		
		p->nRightLink = -1;
		p->nLeftLink = -1;
		pHeapInfo->pHead = p;
		pHeapInfo->pTail = p;
		pHeapInfo->nCount = 1;
	}
	else
	{	
		pHeapInfo->pTail->nRightLink = GetSelfUplink(p);
		p->nLeftLink = GetSelfUplink(pHeapInfo->pTail);
		p->nRightLink = -1;
		pHeapInfo->pTail = p;
		pHeapInfo->nCount++;		
	}
	//
	return;
}

// 左：闲 右：闲
static void FreeMem4(HeapInfo* pHeapInfo, AllocNode* p)
{
	int n;
	n = p->nSize;
	
	AllocNode* pLeftNode;			// 左空闲节点
	pLeftNode = GetLeftNode(pHeapInfo, p);	

	int nUpLink;
	nUpLink = GetSelfUplink(pLeftNode);

	AllocNode* pRightNode;			// 右空闲节点
	pRightNode = (AllocNode *)((char *)p + p->nSize);

	RemoveAt(pHeapInfo, pRightNode);

	pLeftNode->nSize += n + pRightNode->nSize;	
	
	FootLoc(pLeftNode)->nUpLink = nUpLink;	

	return;
}

void FreeMem(HANDLE hHeap, void* pAddr)
{
	HeapInfo* pHeapInfo;
	pHeapInfo = (HeapInfo*)hHeap;

	AllocNode* p;
	p = (AllocNode *)pAddr;
	p--;

	if((char *)p == pHeapInfo->pBuf)
	{	// 释放地址为堆的头		
		if(pHeapInfo->nCount == 0)
		{	// 没有空闲
			FreeMem1(pHeapInfo, p);
			return ;
		}		

		AllocNode* pRightHead;		// 右邻空闲区的头
		pRightHead = (AllocNode *)((char *)p + p->nSize);	// 获取右邻空闲区的头

		int nRightTag;	
		nRightTag = pRightHead->nTag;

		int nLeftTag;	
		nLeftTag = 1;

		if(nRightTag == 1)
		{	// 右忙
			FreeMem1(pHeapInfo, p);
			return ;
		}
		else
		{	// 右闲
			FreeMem3(pHeapInfo, p);
			return ;
		}
	}

	char* pTail;
	pTail = (char *)p + p->nSize;
	if(pTail == pHeapInfo->pBuf + pHeapInfo->nHeapSize)
	{		
		if(pHeapInfo->nCount == 0)
		{	// 没有空闲
			FreeMem1(pHeapInfo, p);
			return ;
		}		

		int nLeftTag;	
		nLeftTag = ((AllocTail *)((char*)p-sizeof(AllocTail)))->nTag;

		int nRightTag;	
		nRightTag = 1;
		if(nLeftTag == 1)
		{	// 左忙
			FreeMem1(pHeapInfo, p);
			return ;
		}
		else
		{	// 左闲
			FreeMem2(pHeapInfo, p);
			return ;
		}		
	}

	int nLeftTag;	
	nLeftTag = ((AllocTail *)((char*)p-sizeof(AllocTail)))->nTag;

	AllocNode* pRightHead;		// 右邻空闲区的头
	pRightHead = (AllocNode *)((char *)p + p->nSize);	// 获取右邻空闲区的头

	int nRightTag;	
	nRightTag = pRightHead->nTag;

	if (nLeftTag == 1 && nRightTag == 1)
	{
		FreeMem1(pHeapInfo, p);
		return ;
	}

	if (nLeftTag == 0 && nRightTag == 1)
	{
		FreeMem2(pHeapInfo, p);
		return ;
	}

	if (nLeftTag == 1 && nRightTag == 0)
	{
		FreeMem3(pHeapInfo, p);
		return ;
	}

	if (nLeftTag == 0 && nRightTag == 0)
	{
		FreeMem4(pHeapInfo, p);
		return ;
	}

	printf("error");

	return ;
}


int GetAddrSize(void* pAddr)
{
	AllocNode* p;
	p = (AllocNode *)pAddr;
	p--;
	return (p->nSize - sizeof(AllocNode) - sizeof(AllocTail) - p->nExtraSize);
}

void FreeAllMem(HANDLE hHeap)
{
	HeapInfo* pHeapInfo;
	pHeapInfo = (HeapInfo *)hHeap;	
	
	pHeapInfo->nCount = 1;
	pHeapInfo->pHead = (AllocNode *)pHeapInfo->pBuf;
	pHeapInfo->pTail = (AllocNode *)pHeapInfo->pBuf;		
	
	AllocNode* pNode;
	pNode = pHeapInfo->pHead;	
	
	pNode->nLeftLink = -1;
	pNode->nTag = 0;
	pNode->nSize = pHeapInfo->nHeapSize;
	pNode->nRightLink = -1;
	
	AllocTail* pTail;
	pTail = FootLoc(pNode);	
	pTail->nUpLink = 0;
	pTail->nTag = 0;
	return;
}

 

6.  数组接口函数使用说明

6.1 CreateHeap()

 

1、功能说明

此函数用来生成一个内存堆数据结构，执行成功后返回一个句柄，之后分配和释放内存的操作都引用此句柄。

 

2、函数原型

HANDLE CreateHeap(int nHeapSize);

 

3、参数说明

  1. int nHeapSize

    输入参数。堆空间的大小, 单位字节, nHeapSize必须大于0。

 

4、返回值

执行成功返回非NULL的句柄，执行失败时返回NULL。

 

5、相关函数

   DestroyHeap(HANDLE hHeap)

 

 

6.2 DestroyHeap ()

1、功能说明

此函数用来释放指定的堆数据结构以及占用的内存。

 

2、函数原型

void DestroyHeap(HANDLE hHeap);

 

3、参数说明

   1）HANDLE hHeap

      输入参数，hHeap是执行CreateHeap函数返回的句柄。

 

4、返回值

    无。

 

5、相关函数

   CreateHugeArray()

 

6.3 AllocMem()

1、功能说明

此函数用来根据数组索引下标获指定取数组元素地址。

 

2、函数原型

Void* AllocHeap(HANDLE hHeap, int nSize);

 

3、参数说明

   1）HANDLE hHeap

      输入参数，hHeap是执行CreateHeap函数返回的句柄。

 

2）int nSize

      输入参数，申请内存的大小，单位：字节。

 

4、返回值

    地址指针

 

5、相关函数

   FreeMem()

 

6.4 FreeMem()

1、功能说明

此函数用来根据数组索引下标获指定取数组元素地址。

 

2、函数原型

Void FreeMem(HANDLE hHeap,void* pAddr);

 

3、参数说明

   1）HANDLE hHeap

      输入参数，hHeap是执行CreateHeap函数返回的句柄。

 

2）void* pAddr

      输入参数，要释放内存的地址，这个地址必须是之前通过AllocMem函数返回的

     地址。

 

4、返回值

    无

 

5、相关函数

   AllocMem()

 

7. demo

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "MemAlloc.h"

int main(int argc, char* argv[])
{
	HANDLE hHeap;
	hHeap = CreateHeap(10*1024*1024);
	
	void* pAddrArray[1024];

	int i;
	for (i = 0; i < 1024; i++)
	{
		pAddrArray[i] = AllocMem(hHeap, 256);
	}

	for (i = 0; i < 1024; i++)
	{
		strcpy(pAddrArray[i], "1234567890");
	}

	for (i = 0; i < 1024; i++)
	{
		printf("%s\r\n", pAddrArray[i]);
	}

	for (i = 0; i < 1024; i++)
	{
		FreeMem(hHeap, pAddrArray[i]);
	}

	DestroyHeap(hHeap);

	return 0;
}

 

编程农场
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
边界标识存储管理：双向循环链表实现分配和回收
大力海棠的博客
04-15 1106
以前写过模拟首次适应、最佳适应和最坏适应法的代码，正好用到动态存储管理算法上，之所以叫动态存储管理（或叫动态存储分配），指用户请求的分配内存是一个动态变量。对于每次大小不同的内存分配，系统都会分配一个地址连续的空闲内存块，系统一开始的内存区是一整个空闲的内存块，随着用户的不断内存申请，这一整块大的空闲内存区，每次会分配出适合的空闲内存块出去，不停分配的同时，也会因为有的程序运行结束了，内存块被回收...
看数据结构写代码（49）边界标识法
fuming0210sc的专栏
04-15 3597
浅谈 内存：内存 两大问题：1. 如何 分配 内存 ？ 2. 如何 回收 释放 的 内存 系统 从 可利用 空间表中  寻找 合适 大小的 内存 分配给用户，并 将 释放的 内存 重新 插入 可利用空间表里，以便 下次 继续 分配给用户。可是 怎么 分配 和 回收呢？ 内存的分配与回收 有三种策略：1. 首次拟合法 2. 最佳拟合法 3.最差拟合法 1.首次拟合法， 内存分配：从 利用空间
C语言内存的动态存储管理4-边界标识法
xiaoshe的专栏
11-09 4511
<br />就空闲链表来说，要确定哪些空闲块是物理地址相邻的，确实不太容易，需要整表扫描。<br />边界标识法能够有效的判断空闲块的物理相邻内存块是否为空闲块。<br />所有的空闲块组成一个双向循环链表，链表中每一个节点的结构如下：<br /><br />llink和rlink分别指向链表中的前驱后继节点。<br />size表明内存块的大小。<br />uplink指向本块的首地址，图中箭头，其作用下面讲述。<br />tag头和尾中各有一个，作为内存块边界的标识，0表空闲块，1表占用块。<br />
7.2、边界标识法管理动态内存
最新发布
融码一生：专注 Python、C/C++、Linux、机器学习 & 深度学习、NLP、算法领域分享
04-16 824
本节介绍一种解决系统中内存碎片过多而无法使用的方法：边界标识法。
边界标识法——分配和回收
lseaJK的博客
09-05 1440
8.3 边界标识法预备知识边界标识法边界标识法结点结构首次拟合法分配回收算法 预备知识 (1) 首次拟合 从表头指针查找，找到的第一个大小不小于m的结点的一部分分配给用户。 分配时需要查找可利用空间表，回收时直接插到表头即可。 (2) 最佳拟合 将可利用空间表中一个不小于m且最接近m的空闲块的一部分分配给用户，推荐按结点从小到大排序，回收时把释放的空闲块插入到合适的位置上。 最佳拟合法适用于请求分配的内存大小范围较广的系统。 最佳拟合无论分配回收都需要查找可利用空间表，因此最费时间。 (3) 最差拟
如何用C语言实现一个简单的内存分配器
liuyanhong13的博客
10-02 1456
Memory Allocator 101-写一个简单的内存分配器 原文：https://arjunsreedharan.org/post/148675821737/memory-allocators-101-write-a-simple-memory 与本文相关的代码： github.com/arjun024/memalloc 可以访问译者的github ，阅读体验更佳... https://github.com/KatePang13/Note/blob/main/%E4%B8%80%E4%B...
Snort源码 C语言实现
12-27
9. **内存管理**：高效且安全的内存管理对于任何C语言程序都至关重要。Snort使用自定义的内存池管理策略，减少内存碎片，提高内存利用率。 10. **错误处理和调试**：Snort源码包含了丰富的错误处理和调试机制，如...
c语言自创军旗游戏源码.zip
03-29
《C语言实现军旗游戏源码解析》 在IT领域，学习编程语言并不仅仅是理论的学习，更重要的是通过实践来巩固和提升技能。本篇将详细探讨一个基于C语言实现的军旗游戏源码，帮助读者深入理解C语言的编程技巧以及游戏...
纯c语言迷宫源码.zip
11-05
"纯C语言迷宫源码"是一个典型的编程实践案例，它展示了如何使用C语言来实现一个迷宫求解算法。下面我们将深入探讨这个主题，解析其中可能包含的知识点。 首先，迷宫问题是一个经典的图论问题，涉及到路径搜索和算法...
c语言支持自己创建迷宫，并求解最短路径.rar
08-10
在C语言中创建一个自定义迷宫并求解最短路径是一个典型的算法问题，涉及到数据结构和算法的应用。这个问题可以通过几种方法解决，其中最常见的可能是深度优先搜索（DFS）和广度优先搜索（BFS）。这两种算法都可以...
纯C语言的俄罗斯和贪吃蛇源码
09-03
学习这两款游戏的源代码，可以深入理解C语言的底层机制，包括内存管理、函数调用、条件判断、循环结构等。同时，也可以学习到如何使用C语言进行图形化编程，尽管这可能需要结合特定的图形库，如SDL或 Allegro。在...
C语言动态存储管理的实现及常见问题分析.
04-10
C语言动态存储管理的实现及常见问题分析.C语言动态存储管理的实现及常见问题分析.
C语言编程规范 学习笔记
Richard_MZ的博客
06-11 2351
C语言编程规范一、代码总体原则二、头文件背景三、函数四、标识符命名与定义五、变量六、宏、常量七、质量保证八、程序效率九、注释十、排版与格式十一、表达式十二、代码编辑、编译十三、可测性十四、安全性十五、单元测试十六、可移植性 一、代码总体原则 1、清晰 代码是给人读的。 清晰的代码易于维护、易于重构。 2.一般情况下，代码的可阅读性高于性能，只有确定性能是瓶颈时，才应该主动优化。 “程序必须为阅读它的人而编写，只是顺便用于机器执行。”——Harold Abelson 和 Gerald Jay Sussm
内存分配—new，malloc，calloc
程序狗的成长之路
11-08 1015
一。关于内存 　1、内存分配方式 　　内存分配方式有三种： 　　（1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在 。例如全局变量，static变量。 　　（2）在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存 储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
内存管理器（二）边界标识法
weixin_30245867的博客
10-12 654
边界标识算法 前言 首先说明，我们这里的内存管理器主要是以模拟各种内存分配算法为主，从内存申请一片内存然后根据我们所选定的数据结构和算法，实现程序的堆空间的分配，至于内存分配详情我们会在Linux内核内存管理的简单分析中探讨。 这个算法是什么 边界标识法是操作系统中用以进行动态分配的一种存储管理的方法，系统将所有的空闲块链接在一个双重循环链表结构中；分配可以按照首次匹...
数据结构算法C语言实现（三十一）--- 8.3边界标识法
diancha6978的博客
06-19 410
　　一.简述 转载于:https://www.cnblogs.com/zhaoyu1995/p/5598880.html
数据结构与算法（C语言）
aiqq136的博客
01-26 5226
目录： 第一章： 数据结构绪论 1.什么是程序：程序 = 数据结构 + 算法 2.逻辑结构&物理结构的区别用法 基本的目标就是将数据及其逻辑关系存储到计算机的内存中 一：逻辑结构: 逻辑结构是指数据对象中数据元素之间的相互关系 逻辑结构是面向问题的 A:集合结构：数据元素除了同属于一个集合外，它们之间没有其他关系 B:线性结构：数据元素之间是一对一关系 C:树形结构：数据元素之间呈现一对多关系 D:图形结构：数据元素是多对多关系 二：物理结构 物理结构是指数据的逻辑结构在.
C语言动态分配内存ppt课件.ppt
11-13
C语言动态内存分配是编程中一项至关重要的技能，它允许程序员在程序运行过程中根据需要动态地为数据结构或对象分配内存，而非在编译时固定大小。本PPT课件详细介绍了动态内存分配的基础概念、实际应用和注意事项。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值