C语言动态内存管理-创新互联

C语言 动态内存管理
  • 引言
    • C/C++程序的内存开辟
    • 声明
  • 一、动态内存管理函数
    • 1. malloc 和 free
      • 使用示例
    • 2. calloc
      • 使用示例
    • 3. realloc
      • 使用示例
    • 4. 注意事项
  • 二、动态内存管理函数使用时的错误示范
    • 程序清单1
    • 程序清单2
    • 程序清单3
    • 程序清单4
    • 程序清单5
    • 程序清单6
  • 三、经典的内存笔试题
    • 程序清单1
    • 程序清单2
    • 程序清单3
    • 程序清单4
    • 程序清单5

成都一家集口碑和实力的网站建设服务商，拥有专业的企业建站团队和靠谱的建站技术，10余年企业及个人网站建设经验 ,为成都超过千家客户提供网页设计制作,网站开发,企业网站制作建设等服务,包括成都营销型网站建设，品牌网站制作，同时也为不同行业的客户提供网站制作、成都网站制作的服务,包括成都电商型网站制作建设,装修行业网站制作建设，传统机械行业网站建设,传统农业行业网站制作建设。在成都做网站,选网站制作建设服务商就选创新互联。引言 C/C++程序的内存开辟

1-1

1. 栈区：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限，所以有时候会出现栈溢出的情况。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

2. 堆区：一般由程序员分配、释放， 若程序员不释放，程序结束时可能由操作系统回收，分配方式类似于链表。

3. 数据段 ( 静态区 static ) 存放全局变量、静态数据，程序结束后由系统释放。

4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

声明

在我们平时写程序时，创建的变量都会在底层开辟内存。C语言 的内存布局分为三大块：栈区、堆区、静态区。其中栈区是我们平时使用最多的区域，栈区的使用习惯：先使用高地址处的空间，再使用低地址处的空间。然而栈区的使用总是有限的，所以本篇博客重点介绍如何使用堆区的内存。

1-2

一、动态内存管理函数 1. malloc 和 free

malloc - memory allocate - 分配一段连续的内存空间

void* malloc (size_t size);

// 返回值：申请内存成功，则返回开辟好空间的头指针；申请内存失败，则返回 NULL
// 参数：以字节为单位的申请值

free - 释放并回收内存

void free (void* ptr);

// 参数：ptr 为先前用 malloc、calloc 或 realloc分配的内存块的头指针
// 注意：一定要是头指针，而不是中间的指针，否则就会出现释放内存不干净的情况
使用示例
#include#includeint main() {	int* p = (int*) malloc(40); // 申请空间

	if (p == NULL) {// 内存分配失败的情况
		perror("malloc");
		return 1;
	}

	for (int i = 0; i< 10; i++) {*(p + i) = i; 		// 为刚刚开辟的空间放入值
	}

	free(p);				// free 将刚刚系统开辟的空间，再回收掉
	p = NULL;				// 为了防止 ptr 成为野指针，所以将其置成 NULL
	return 0;
}
2. calloc

calloc - 分配一段连续的内存空间并清零

calloc 函数 和 malloc 函数的使用思想基本相同，只不过前者在分配内存之后，又做了清零的步骤。

void* calloc (size_t num, size_t size);

// 返回值：申请内存成功，则返回开辟好空间的头指针；申请内存失败，则返回 NULL
// 参数：num 表示元素个数，size 表示每个元素的字节大小
使用示例
#include#includeint main() {int* p = (int*) calloc(10, sizeof(int)); // 申请 10*4 = 40 个字节
	
	if (p == NULL) {perror("calloc");
		return 1;
	}

	for (int i = 0; i< 10; i++) {printf("%d ", *(p + i));
	}
	
	free(p); 	// 释放
	p = NULL;

	return 0;
}

// 输出结果：0 0 0 0 0 0 0 0 0 0
3. realloc
void* realloc (void* ptr, size_t size);

使用 realloc 再次申请分配内存的时候，需要指定重新开辟内存的字节总大小。假设我们之前使用 malloc / calloc 申请内存时，内存不够用了，realloc 就会派上用场。它可以做到很人性化地开辟内存。

情况①：当 malloc / calloc 申请的内存后面，有足够的空间再次扩充，realloc 就能够直接接着上次的位置，继续开辟。最终还是返回上一次开辟的原地址。

情况②：当 malloc / calloc 申请的内存后面，没有足够的空间再次扩充，realloc 也能够另起一块内存区域，将之前申请的内存中的数据也一并放入到新的内存区域中。此时最终返回的是新的地址。

使用示例
#include#includeint main() {int* p = (int*) malloc(40);      // 1

	if (p == NULL) {perror("malloc");
		return 1;
	}

	for (int i = 0; i< 10; i++) {*(p + i) = i;
	}

	int* ptr = (int*)realloc(p, 80); // 2
	if (ptr != NULL) {		 // 3
		p = ptr;
	}
	
	free(p);						 // 4			
	p = NULL;			
	return 0;
}

// 1. malloc 申请分配内存。

// 2. 假设空间不够，使用 realloc 再次申请。

// 3. 由于内存有限，所以 realloc 也有可能申请内存失败，当失败的时候就会返回 NULL. 只有当 ptr 不为空的时候，才能够放入 p 中，这样就能保证 p 不受影响。

// 4. 释放内存

4. 注意事项

申请内存分配后，始终需要记得使用 free. 当我们不释放动态申请的内存的时候，如果程序结束，动态申请的内存由操作系统自动回收；但如果程序不结束，动态内存是不会自动回收的，就会形成内存泄露的问题，久而久之，内存就会被 " 耗干 "。

虽然现在的操作系统很智能，能够限制一些程序的内存使用，但还是建议标准化。

二、动态内存管理函数使用时的错误示范 程序清单1

动态内存申请失败，对 NULL 直接进行了解引用操作。

#include#include#includeint main () {int* p = malloc(INT_MAX); // 申请失败
	*p = 100; // error

	free(p);
	p = NULL;

	return 0;
}
程序清单2

对动态开辟空间的越界访问。

#include#includeint main() {int* p = malloc(40); // 开辟 40 个字节的内存
	if (p == NULL) {perror("malloc");
		return 1;
	}

	// 越界访问 41 ~ 44
	for (int i = 0; i< 11; i++) {*(p + i) = i;
	}

	free(p);
	p = NULL;

	return 0;
}
程序清单3

对非动态开辟内存使用 free 释放.

#include#includeint main() {int a = 10;
	int* p = &a;

	free(p); // error
	p = NULL;

	return 0;
}
程序清单4

free 释放不完整，或者 free 函数接收的指针不处于内存开辟的头部。

#include#includeint main() {int* p = (int*) malloc(100);
	if (p == NULL) {perror("malloc");
		return 1;
	}

	for (int i = 0; i< 10; i++) {*p = i;
		p++;
	}

	free(p); // error
	p = NULL;

	return 0;
}

从第 40 个字节后面开始释放内存，那么前面的内存就未被释放完。

1-3

程序清单5

对同一块动态内存多次释放。

#include#includeint main() {int* p = malloc(100);

	if (p == NULL) {perror("malloc");
		return 1;
	}
	
	free(p);
	free(p); // error
	p = NULL;

	return 0;
}
程序清单6

内存泄漏。

如下程序，在 test 函数中，即使我们写了 free，但最终走不到释放的代码，依然会存在内存泄漏的问题。所以说，free 代码的放置位置很关键，并不是写了 free 就一定能够释放动态内存。

#include#includevoid test() {int* p = (int*)malloc(100);
	if (1) {return;
	}

	free(p); // 代码走不到这一行
	p = NULL;
}

int main() {test();
	return 0;
}
三、经典的内存笔试题 程序清单1
#include#include#includevoid getMemory(char* p)
{p = (char*) malloc(100);
}

int main() {char* str = NULL;
	getMemory(str);
	strcpy(str, "hello world"); // 对空指针解引用

	printf(str);

	return 0;
}

分析：

在 getMemory 函数中，在堆区申请了 100 个字节的内存大小，之后我们可以通过指针 p 来找到这些内存。然而，在主函数中，str 始终为 NULL. 也就是说，str 并没有指向任何一块区域，所以后面在使用 strcpy 函数的时候，" hello world " 就不能成功拷贝。

这题错误的主要原因就是 str 为实参，p 为形参，对形参的操作不影响实参。

1-4

程序清单2
#include#include#includevoid getMemory(char** p, int num)
{*p = (char*) malloc(num); // 相当于 str 指向了开辟的 100 个字节的空间
	// *(&str)<==>str = (char*) malloc(100); 
}

int main() {char* str = NULL;
	getMemory(&str, 100);
	
	strcpy(str, "hello");
	printf(str);

	free(str); 			
	str = NULL; 		

	return 0;
}

// 输出结果： hello

分析：

程序清单2 算是 对 程序清单1 的优化，在 getMemory 函数中，当我们传过去的是 str 的地址时，再次对二级指针解引用，就相当于能够通过 str 直接找到开辟的内存。上面的程序没有问题，但是我们也不要忘记 free 来帮助系统回收内存了。

1-5

程序清单3
#include#include#includechar* getMemory()
{char p[] = "hello world";
	return p;
}

int main() {char* str = NULL;
	str = getMemory();
	printf(str);

	return 0;
}

// 输出结果：随机值

分析：

数组 p 在栈区开辟了内存，但出了 getMemory 函数后，数组中之前所占用的空间就被操作系统销毁了，也就是说，刚刚栈区的内存还给了系统，现在出了函数后，即使知道这块内存的地址，但已经没有权限再次使用这块区域了。因为数组 p 是一个临时的局部变量。

p 表示数组的首元素地址，假设 p 的地址为 0x11223344，那么出了 getMemory 函数后，现在 0x11223344 指向的内存可能已经被其他数据占用了。所以在主函数中，当 str 再次指向 0x11223344，找到的就是一些随机存放的数据。

1-6

程序清单4
#includeint* test() {int a = 10;
	return &a;
	// 出了 test 函数，a 的地址将被系统回收
}

int main() {int* p = test();

	return 0;
}

程序清单4 和 程序清单3 的错误思想基本相同，这是典型的 【返回栈空间地址、野指针】的问题。a 的地址出了 test 函数后，就需要被回收，所以后续在主函数中，指针 p 就没有权限去操作这块内存区域。

为什么栈区的地址最后需要被回收？
答：因为函数和局部变量在使用时，需要在栈区开辟内存，当用完了，如果不被回收，那么操作系统的内存迟早要被耗尽。

举个例子：这就和住酒店一样，当 旅客 A 租完了房子，房子就需要打扫干净，腾出来给后面的 旅客B / 旅客C / 旅客D… 使用。否则，房子永远不够后面的旅客使用。如果 旅客A 前脚刚走，旅客B 就住进去了，那么这个房子暂时属于 旅客B 的，假设 旅客A 发现自己手机留在了刚刚的房子忘拿了，那么 旅客A 就需要和前台报备一下，如果 旅客A 直接冲进去了刚刚的房子找手机，旅客B 就会告他非法访问。

程序清单5
#includevoid test(){char* str = (char*) malloc(100);
	strcpy(str, "hello");
	free(str);
	
	if (str != NULL){		
		// 野指针，非法操作
		strcpy(str, "world");
		printf(str);
	}
}

int main() {test();
	return 0;
}

上面的代码依旧是野指针问题，当 malloc 开辟的堆区内存区域被 free 回收之后，str 指向的地址依旧是刚刚申请的头部地址，但此时却没有了操作这块内存的权限。所以将 " world " 字符串放入 str 指向的区域，最终就会造成非法访问。

综上所述，我们应该在 free 的后面添加如下代码：

str = NULL; // 防止 str 成为一个野指针

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧

本文标题：C语言动态内存管理-创新互联
文章链接：https://www.cdcxhl.com/article0/dpogio.html

成都网站建设公司_创新互联，为您提供网站营销、微信公众号、面包屑导航、ChatGPT、搜索引擎优化、软件开发

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

成都网站建设公司

外贸建站知识

分类信息网站