【C】动态内存管理详解

CSDN话题挑战赛第2期
参赛话题：学习笔记

前言

这篇博客的内容是三个动态内存函数、常见的错误以及一些笔试题。希望读者阅读完能加深对动态内存管理的理解，能有所收获。

一 为什么存在动态内存分配

目前我们已经知道了几种存储方式

int num = 20;
char str[10] = {10};

但是上面的存储方式存在一些问题

1. 空间开辟的大小是固定的。
2. 数组大小必须在定义时申明，需要的内存在编译时分配。

显然这是远远不够的，我们需要能够实现能够改变大小的空间，而且能够自己输入开辟内存的大小（在运行时输入）。

二 动态内存函数的介绍

1.malloc

void* malloc (size_t size);

分配一块size字节的内存，并返回一个void*的指针。

• 如果开辟成功则返回一个指向这块内存的指针。
• 开辟失败会返回NULL，因此一定要记得验证是否是空指针再使用。
• 返回的指针是void*，因此使用时需要用户自己修改。
• 如果size为0，malloc的行为是未定义的，取决于编译器。

size_t :
它是一种“整型”类型，里面保存的是一个整数，就像int那样。这种整数用来记录一个大小(size)，通常我们用sizeof(XXX)操作，这个操作所得到的结果就是size_t类型，单位是字节。

2.free

void free (void* ptr);

这个函数的作用是释放内存块。先前通过调用 malloc、calloc 或 realloc 分配的内存块被释放，使其再次可用于进一步分配。

• 如果 ptr 没有指向使用上述函数分配的内存块，则会导致未定义的行为。（常见错误）
• 如果 ptr 是空指针，则该函数不执行任何操作。
• 请注意，此函数不会更改ptr本身的值，因此它仍然指向相同（已经无效）的位置。

注意：
由后面的两点我们知道，在用free释放动态分配的内存之后我们会得到一个野指针，因此通常free之后会加上ptr = NULL。

举个例子：

#include <stdio.h>
int main()
{
	 //代码1
	 int num = 0;
	 scanf("%d", &num);
	 int arr[num] = {0};
	 
	 //代码2
	 int* ptr = NULL;
	 ptr = (int*)malloc(num*sizeof(int));
	 if(NULL != ptr)//判断ptr指针是否为空
	 {
		 int i = 0;
		 for(i=0; i<num; i++)
		 {
			 *(ptr+i) = 0；
		 }
	 }
	 free(ptr);//释放ptr所指向的动态内存
	 ptr = NULL;//很有必要
	 return 0;
}

之前我们开辟空间可能使用代码1的的方法，现在我们可以尝试第二种。

3.calloc

void* calloc (size_t num, size_t size);

为 num 个元素的数组分配一块内存，每个元素的大小为字节长，并将其所有位初始化为零。

举个例子：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)calloc(4, 10);
	free(p);
	p = NULL;
	return 0;
}

4.realloc

void* realloc (void* ptr, size_t size);

realloc的作用： 重新分配内存块（更改 ptr 指向的内存块的大小）。

• ptr是要调整的内存地址
• size是重设的大小
• 返回值为调整后的内存起始位置
• realloc会将调整后的内存移到新的空间
• realloc在调整空间时存在两种情况：
  • 原有空间之后有足够大的空间
  • 原有空间之后没有足够大的空间

情况1：
要扩展内存直接在原有内存之后追加空间，原有数据不变化
情况2：
在堆空间上另找一个合适大小的连续空间来使用，原有的数据被拷贝到新空间。这样函数返回的是一个新的内存地址。

因此当我们定义了一块空间ptr，想要使用realloc时

#include <stdio.h>
int main()
{
	 int *ptr = (int*)malloc(100);
	 if(ptr != NULL)
	 {
	     //业务处理
	 }
	 else
	 {
	     exit(EXIT_FAILURE);    
	 }
	 int*p = NULL;
	 p = realloc(ptr, 1000);
	 if(p != NULL)
	 {
		 ptr = p;
	 }
	 free(ptr);
	 return 0;
}

我们最好定义一个新的指针p，将realloc返回的空间赋给p，再判断p是否为空指针。防止ptr中数据被更改。

三 常见动态内存错误

1.对NULL指针的解引用

void test()
{
	 int *p = (int *)malloc(INT_MAX/4);
	 *p = 20;//如果p的值是NULL，就会有问题
	 free(p);
}

2.越界访问

void test()
{
	 int i = 0;
	 int *p = (int *)malloc(10*sizeof(int));
	 if(NULL == p)
	 {
	 exit(EXIT_FAILURE);
	 }
	 for(i=0; i<=10; i++)
	 {
	 *(p+i) = i;//当i是10的时候越界访问
	 }
	 free(p);
}

3.非动态开辟内存的free

void test()
{
	 int a = 10;
	 int *p = &a;
	 free(p);
}

4.free释放动态开辟内存的一部分

void test()
{
	 int *p = (int *)malloc(100);
	 p++;
	 free(p);//p不再指向动态内存的起始位置
}

5.同一块内存的多次释放

void test()
{
	 int *p = (int *)malloc(100);
	 free(p);
	 free(p);//重复释放
}

当我们使用free释放空间之后给指针赋为NULL可以预防多次释放，因为free空指针不会产生什么不良影响。

6.内存泄漏

void test()
{
	 int *p = (int *)malloc(100);
	 if(NULL != p)
	 {
	 	*p = 20;
	 }
}
int main()
{
	 test();
	 while(1);
}

四 经典笔试题

1.题目一

void GetMemory(char *p)
{
	 p = (char *)malloc(100);
}
void Test(void)
{
	 char *str = NULL;
	 GetMemory(str);
	 strcpy(str, "hello world");
	 printf(str);
}

显然这个程序无法运行，因为str仍指向空指针。注意，GetMemory的实参是str即指针本身，因此形参只能接收它的值NULL，而且p出了函数就会销毁。我们可以用传址来修改。

#include <stdio.h>
#include <stdlib.h>
void GetMemory(char** p)
{
	*p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);
	strcpy(str, "hello world");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

printf后面直接加指针也可以输出

2.题目二

char *GetMemory(void)
{
	 char p[] = "hello world";
	 return p;
}
void Test(void)
{
	 char *str = NULL;
	 str = GetMemory();
	 printf(str);
}

显然str是一个野指针，因为p指向的空间在GetMemory中被定义，所以出了函数这个空间就没有了，p把一个没有意义的地址赋给了str。

3.题目三

void GetMemory(char **p, int num)
{
	 *p = (char *)malloc(num);
}
void Test(void)
{
	 char *str = NULL;
	 GetMemory(&str, 100);
	 strcpy(str, "hello");
	 printf(str);
}

定义了动态内存空间但是没有释放，造成内存泄漏。

4.题目四

void Test(void)
{
	 char *str = (char*)malloc(100);
	 strcpy(str, "hello");
	 free(str);
	 if(str != NULL)
	 {
		 strcpy(str, "world");
		 printf(str);
	 }
}

str指向的内存被释放之后，str就变成了野指针，不能使用。

最后

如果这篇文章有帮到你，不妨点赞、收藏、关注。
感谢支持！！！