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语言动态内存管理-创新互联
URL网址:http://scyanting.com/article/dpogio.html