devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言----动态内存分配（malloc calloc relloc free）超全知识点_c语言动态分配内存malloc

作者：IT小白 | 2024-05-19 09:24:59

赞

踩

c语言动态分配内存malloc

目录

一.动态内存函数 

1.malloc

2.free

3.calloc

4.malloc和calloc的区别

5.realloc

二.动态内存分配的常见错误

1.对null进行解引用操作

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

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

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

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

6.动态开辟内存忘记释放（内存泄漏）

三.习题讲解

1.代码找错

（1）内存泄漏

（2）返回栈空间地址的问题

（3）非法访问内存

四.柔性数组

一.动态内存函数 

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

2.堆区(heap):一般由程序员分配释放，若程序员不释放，程序结束时可能由OS(操作系统)回收。分配方式类似于链表。
3.数据段(静态区)(static)存放全局变量、静态数据。程序结束后由系统释放

实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁

但是被static修饰的变量存放在数据段(静态区)，数据段的特点是在上面创建的变量，直到程序结束才销毁，所以生命周期变长

4.代码段:存放函数体(类成员函数和全局函数)的二进制代码。

动态内存分配是在堆区进行的 

int val = 20;//在栈空间上开辟四个字节

char arr [ 10 ] = { 0 }; // 在栈空间上开辟 10 个字节的连续空间
开辟空间的方式有两个特点：
1. 空间开辟大小是固定的。
2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配
但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，数组的编译时开辟空间的方式就不能满足了，这时候就只能试试动态内存开辟 

例如

虽然C语言是可以支持变长数组--c99中增加了，但是很多编译器是不支持c99的，所以变长数组没有办法使用，即arr[n],所以已有的分配内存空间的方式是局限的，所以要进行动态内存分配

  1. struct S
  2. {
  3. 	char name[20];
  4. 	int age;
  5. }
  6.  
  7. int main()
  8. {
  9. 	int n=0;
  10. 	scanf("%d",&n);
  11. 	struct S arr[n];
  12. 	
  13. 	return 0;
  14. }

1.malloc

void* malloc (size_t size)   动态内存开辟

这个函数向内存申请一块 连续可用 的空间，并返回指向这块空间的指针。
如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个 NULL 指针，因此 malloc 的返回值一定要做检查。
返回值的类型是 void* ，所以 malloc 函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
如果参数 size 为 0 ， malloc 的行为标准是未定义的，取决于编译器。

malloc包含的几个要素 

  1. //1.
  2. #include<stdlib.h>
  3. int main()
  4. {
  5. //2.
  6.     int* p=(int*)malloc(10*sizeof(int));//malloc是void*型,所以要进行强制类型转换，但是在Gcc环境下或者说linux环境下是不需要进行转换的
  7. }

代码如下(还没有回收释放空间)

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<errno.h>
  4. #include<string.h>
  5. int main()
  6. {
  7. 	int* p=(int*)malloc(10*sizeof(int));
  8. 	if(p==NULL)
  9. 		printf("%s",strerror(errno));//开辟空间失败，可以用strerror显示错误结果
  10. 	else
  11.     {
  12. 		for(int i=0;i<10;i++)
  13. 		{
  14. 			//把每个元素打印出来 
  15. 			*(p+i)=i;
  16. 		}
  17. 		for(int i=0;i<10;i++)
  18. 		{
  19. 			printf("%d",*(p+i));
  20. 		} 
  21.     }
  22. 	return 0;	
  23. }

 如果将其中的

    int* p=(int*)malloc(10*sizeof(int));

改为

     int* p=(int*)malloc(10*sizeof(INT_MAX));

系统会报错，错误信息为not enough space

（1）INT_MAX ：INT_MAX 是 C++ 中 <climits> 头文件中定义的一个宏，用于表示 int 类型的最大值。该宏在 C 和 C++ 中都可以使用，他不是数据类型。

如果想正确使用INT_MAX开辟空间，代码如下

  1. //在C++中使用new开辟一块新的空间
  2. #include <iostream>
  3. #include <climits> // 包含 INT_MAX 的头文件
  4.  
  5. using namespace std; // 引入命名空间
  6.  
  7. int main() {
  8.     int* p = new int[10]; // 使用 new 关键字动态分配内存
  9.  
  10.     for (int i = 0; i < 10; ++i) {
  11.         p[i] = INT_MAX; // 给每个元素赋值为 INT_MAX
  12.     }
  13.  
  14.     for (int i = 0; i < 10; ++i) {
  15.         cout << p[i] << " ";
  16.     }
  17.     cout << endl;
  18.  
  19.     delete[] p; // 释放动态分配的内存
  20.  
  21.     return 0;
  22. }

2.free

C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的（堆区），函数原型如下：

void free ( void* ptr );
free 函数用来释放动态开辟的内存。
如果参数 ptr 指向的空间不是动态开辟的，那 free 函数的行为是未定义的。
如果参数 ptr 是 NULL 指针，则函数什么事都不做。

完整代码如下：

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<errno.h>
  4. #include<string.h>
  5. int main()
  6. {
  7. 	int* p=(int*)malloc(40);
  8. 	if(p==NULL)
  9. 		printf("%s",strerror(errno));//开辟空间失败，可以用strerror显示错误结果
  10. 	else
  11.     {
  12. 		for(int i=0;i<10;i++)
  13. 		{
  14. 			//把每个元素打印出来 
  15. 			*(p+i)=i;
  16. 		}
  17. 		for(int i=0;i<10;i++)
  18. 		{
  19. 			printf("%d",*(p+i));
  20. 		}
  21.     }
  22.         //当动态申请的空间不再使用的时候
  23.         //就应该还给操作系统
  24.     free(p);//即使我们将p还给了操作系统，但是p依然指向这块空间,所以要进行p=NULL
  25.     p=NULL;//使p不指向这块内存空间
  26. 	return 0;	
  27. }

 3.calloc

calloc 函数也用来动态内存分配。原型如下：
void* calloc ( size_t num , size_t size );
函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为 0 。
与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全 0 

calloc的几个要素

  1. //1.
  2. #include<stdlib.h>
  3. #include<malloc.h>
  4. int main()
  5. {
  6. //2.
  7. //malloc(10*sizeof(int))
  8.     int *p=(int*)calloc(10,sizeof(int));
  9.     return 0;
  10.  
  11. }

代码如下

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<errno.h>
  4. #include<string.h>
  5. #include<malloc.h>
  6. int main()
  7. {
  8. 	int* p=(int*)calloc(10,sizeof(int));
  9. 	if(p==NULL)
  10. 		printf("%s",strerror(errno));//开辟空间失败，可以用strerror显示错误结果
  11. 	else
  12.     {
  13. 		for(int i=0;i<10;i++)
  14. 		{
  15. 			//把每个元素打印出来 
  16. 			*(p+i)=i;
  17. 		}
  18. 		for(int i=0;i<10;i++)
  19. 		{
  20. 			printf("%d",*(p+i));
  21. 		} 
  22.     }
  23.     free(p);//free函数是用来释放动态开辟的空间的
  24.     p=NULL;
  25. 	return 0;	
  26. }

4.malloc和calloc的区别

1.malloc和calloc的开辟空间形式不同

2.calloc会初始化空间为0，而malloc不会初始化。所以malloc开辟空间效率更高，但不会将空间的每个字节初始化为0

5.realloc

realloc 函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。
函数原型如下：
void* realloc ( void* ptr , size_t size );
ptr 是要调整的内存地址
size 调整之后新大小
返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。
realloc 在调整内存空间的是存在两种情况：
情况 1 ：原有空间之后有足够大的空间
对策：要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化
情况 2 ：原有空间之后没有足够大的空间
对策：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

代码如下

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<errno.h>
  4. #include<string.h>
  5. int main()
  6. {
  7. 	int* p=(int*)malloc(20);
  8. 	if(p==NULL)
  9. 		printf("%s",strerror(errno));//开辟空间失败，可以用strerror显示错误结果
  10. 	else
  11.     {
  12. 		for(int i=0;i<10;i++)
  13. 		{
  14. 			//把每个元素打印出来 
  15. 			*(p+i)=i;
  16. 		}
  17.     }
  18.     //假设这里20个字节的空间不够用了,我们希望使用40个字节的空间
  19.     //这时候就可以使用realloc来调整动态开辟的空间
  20.     int* p2=realloc(p,40);
  21.     for(int i=5;i<10;i++)
  22.     {
  23.         *(p2+i)=i;
  24.     }
  25.     for(int i=0;i<10;i++)
  26.     {
  27.         printf("%d",*(p2+i));
  28.     }
  29. 	return 0;	
  30. }

 在这里，用了p,p2两个指针指向不同的内存空间，这样p就不是统一管理所有的空间，所以这样做不对，追加空间有有以下两种情况：

1.开辟的空间后面正好有足够的空间能够追加内存，开辟内存空间后也是p指向内存首元素，返回的是p（旧的指针）

 2.如果开辟的空间后没有足够的空间，那么就重新开辟一块新的空间，把原来的地址里面的数据，拷贝到新开辟的更大的空间中

第一种方法返回的是旧的地址

第二种方法返回的是不同的新开辟的内存空间地址，旧的空间free()

注意：

int* p=realloc(p,40);

如果realloc内存开辟失败，返回NULL(空指针)，那么p原来开辟的空间也找不到了,所以不能赋值到原来开辟的内存空间，应该这样写：

  1. int* ptr=realloc(p,40);//用新变量接收realloc的返回值
  2. if(ptr!=NULL)
  3. {
  4. 	p=ptr;//仍然用p维护新的内存
  5. } 
  6. int i=0;

完整代码如下

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<errno.h>
  4. #include<string.h>
  5. int main()
  6. {
  7. 	int* p=(int*)malloc(20);
  8. 	if(p==NULL)
  9. 		printf("%s",strerror(errno));//开辟空间失败，可以用strerror显示错误结果
  10. 	else
  11.     {
  12. 		for(int i=0;i<5;i++)
  13. 		{
  14. 			//把每个元素打印出来 
  15. 			*(p+i)=i;
  16. 		}
  17.     }
  18.     //假设这里20个字节的空间不够用了,我们希望使用40个字节的空间
  19.     //这时候就可以使用realloc来调整动态开辟的空间
  20.     int* p2=realloc(p,40);
  21.  
  22.    	if(p2!=NULL)
  23.    	{
  24.    		p=ptr;
  25.    		for(i=5;i<10;i++)
  26.    		{
  27.    			*(p+i)=i;
  28. 		}
  29. 		for(i=0;i<10;i++)
  30. 		{
  31. 			printf("%d",*(p+i));
  32. 		}
  33. 	}
  34. 	free(p);
  35. 	p=NULL;
  36. 	return 0;	
  37. }

二.动态内存分配的常见错误

1.对null进行解引用操作

  1. int main()
  2. {
  3.     int *p=(int*)malloc(40);//万一解引用失败,p就被赋值为null
  4.     *p=0//err;
  5.     
  6.     int i=0;
  7.     for(int i=0;i<10;i++)
  8.     {
  9.         *(p+i)=i;    
  10.     }
  11.     free(p);
  12.     p=NULL;
  13.     return 0;
  14.  
  15. }

所以在解引用操作前要作出判断

  1. int main()
  2. {
  3.     int *p=(int*)malloc(40);//万一解引用失败,p就被赋值为null
  4.     if(p!=NULL)
  5.     {
  6.         *p=0//err;
  7.     
  8.         int i=0;
  9.         for(int i=0;i<10;i++)
  10.         {
  11.             *(p+i)=i;    
  12.         }
  13.         free(p);
  14.         p=NULL;
  15.         return 0;
  16.     }
  17. }

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

  1. int main()
  2. {
  3.     int *p=(int*)malloc(5*sizeof(int));
  4.     if(p==NULL)
  5.         return 0;
  6.     else 
  7.     {
  8.         for(int i=0;i<10;i++)//本来只有5个整型元素,访问10个的话会越界
  9.         {
  10.             *(p+i)=i;
  11.         }
  12.     }
  13.     //
  14.     free(p);
  15.     p=NULL;
  16.     return 0;
  17. }

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

  1. int a=10;
  2. int* p=&a;
  3. *p=20;
  4. free(p);
  5. p=NULL;

a的空间是在栈区存放的，程序会出错

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

  1. #include<stdio.h>
  2. {
  3. int *p=(int*)malloc(40);
  4. if(p==NULL)
  5. {
  6.     return 0;
  7. }
  8. int i=0;
  9. for(i=0;i<10;i++)
  10. {
  11.     *p++=i;
  12. }
  13. free(p);
  14. p=NULL;//在这里p已经变化了，不是最初指向的空间了
  15. return 0;
  16. }

 代码应该改为

  1. for(i=0;i<10;i++)
  2. {
  3.     *(p+i)=i;
  4. }

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

  1. int *p=(int*)malloc(40);
  2. if(p==NULL)
  3.     return 0;
  4. else{
  5.     ....
  6.     free(p);
  7.     free(p);
  8.     p=NULL;
  9.     return 0;
  10. }

或者这样,这样不会报错（每次释放完后，p所指向的地址置为空指针）

  1. free(p);
  2. p=NULL;
  3. free(p);

6.动态开辟内存忘记释放（内存泄漏）

  1. while(1)
  2. {
  3.     malloc(1);
  4.     sleep(1000);    
  5. }
  6. return 0;

三.习题讲解

1.代码找错

（1）内存泄漏

 这里有几个错误

(1)调用完GetMemory之后，p是GetMemory中的一个形参变量，p在这个函数内有效，出了这个函数之后就无效了，等GetMemory函数返回之后，动态开辟内存尚未释放并且无法找到，所以会造成内存泄漏，所以在这里str还是空指针，不是有效的地址，所以

strcpy(str,"hello world");//str并没有指向有效的地址，而是一块空指针

（2）没有free(),会出现内存泄露问题

  1. void GetMemory(char **p)//对char *的地址解引用就是**p,p中存放的是str的地址,那么*p就是str
  2. {
  3.     *p=(char *)malloc(100);
  4. }
  5.  
  6. void Test(void)
  7. {
  8.     char *str=NULL;
  9.     GetMemory(&str);
  10.     strcpy(str,"hello world");
  11.     printf(str);
  12.     free(str);
  13.     str=NULL;
  14. }
  15.  
  16. int main()
  17. {
  18.     Test();
  19.     return 0;
  20. }

或者

  1. char* GetMemory(char *p)//对char *的地址解引用就是**p,p中存放的是str的地址,那么*p就是str
  2. {
  3.     p=(char *)malloc(100);
  4.     return p;
  5. }
  6.  
  7. void Test(void)
  8. {
  9.     char *str=NULL;
  10.     str=GetMemory(str);
  11.     strcpy(str,"hello world");
  12.     printf(str);
  13.     free(str);
  14.     str=NULL;
  15. }
  16.  
  17. int main()
  18. {
  19.     Test();
  20.     return 0;
  21. }

（2）返回栈空间地址的问题

 （1）str=GerMemory();//确实将返回值放到了str中，但是执行完该代码后，p的空间就还给操作系统了，所以当printf(str)打印时，str指向哪块空间就不清楚了，同理

  1. int *test()
  2. {
  3.     int a=10;
  4.     return &a;
  5. }
  6.  
  7.  
  8. int main()
  9. {
  10.     int *p=test();//非法访问内存空间
  11.     *p=20;
  12.     return 0;
  13.  
  14. }

可以改为

  1. int *test()
  2. {
  3.     //int a=10;//栈区
  4.     static int a=10;//将a放在静态区中，栈空间的地址返回存在风险，但是静态区不会
  5.     return &a;
  6. }
  7.  
  8.  
  9. int main()
  10. {
  11.     int *p=test();
  12.     *p=20;
  13.     return 0;
  14.  
  15. }

也可以写为

  1. int* test()
  2. {
  3.     int *ptr=malloc(100);//在堆区,如果不free依然存在
  4.     return ptr;
  5.  
  6. }
  7.  
  8. int main()
  9. {
  10.     int *p=test();
  11.     return 0;
  12.  
  13. }

（3）非法访问内存

篡改动态内存区的内容，后果难以预料，非常危险。
因为free(str);之后，str成为野指针if(str!=NULL)语句不起作用

  1. void test(void)
  2. {
  3.     char *str=(char*)malloc(100);
  4.     strcpy(str,"hello");
  5.     free(str);//虽然str开辟的区域已经还给操作系统了,但是str还是指向这块区域
  6.     if(str!=NULL)//这里判断为真，world覆盖hello,打印了world,但是这块空间已经被释放了，不能使用了，但是还是打印了world，非法访问
  7.     {
  8.         strcpy(str,"world");
  9.         printf(str);
  10.     }
  11. }
  12.  
  13. int main()
  14. {
  15.     test();
  16.     return 0;
  17. }

代码修改为

  1. void test(void)
  2. {
  3.     char *str=(char*)malloc(100);
  4.     strcpy(str,"hello");
  5.     free(str);//虽然str开辟的区域已经还给操作系统了,但是str还是指向这块区域
  6.     str=NULL;//这样下面的判断(str!=NULL)才有意义
  7.     if(str!=NULL)
  8.     {
  9.         strcpy(str,"world");
  10.         printf(str);
  11.     }
  12. }
  13.  
  14. int main()
  15. {
  16.     test();
  17.     return 0;
  18. }

四.柔性数组

C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做[柔性数组]成员

运用柔性数组 

  1. struct S
  2. {
  3.     int n;
  4.     int arr[];//未知大小的,柔性数组成员，数组大小是可以改变的
  5. }
  6.  
  7. int main()
  8. {
  9.     struct S s;
  10.     printf("%d\n",sizeof(s));//结果为4
  11.     struct S* ps=(struct S*)malloc(sizeof(struct S)+5*sizeof(int));
  12. //为arr开辟了5个int型的地址空间
  13.     ps->n=100;
  14.     for(int i=0;i<5;i++)
  15.     {
  16.         ps->arr[i]=i//0 1 2 3 4 5 
  17.     }
  18.     Struct *ptr=realloc(ps,44);//原来是24个字节,现在是44个字节，多个5个整型变量
  19.     if(ptr!=NULL)
  20.         ps=ptr;
  21.     for(int i=5;i<10;i++)
  22.     {
  23.         ps->arr[i]=i;
  24.     }
  25.     for(int i=0;i<10;i++)
  26.     {
  27.          printf("%d",ps->arr[i]);  
  28.     }
  29.     free(ps);
  30.     ps=NULL;
  31.  
  32.     return 0;
  33. }

 另一种写法，不适用柔性数组，开辟空间的方式有一些区别，但是总体得到的结果相同

  1. struct S
  2. {
  3.     int n;
  4.     int* arr;
  5.  
  6. }
  7.  
  8. int main()
  9. {
  10.     struct S*ps = (struct S*)malloc(sizeof(struct S));
  11.     ps->arr=malloc(5*sizeof(int));
  12.     int i=0;
  13.     for(i=0;i<5;i++)
  14.     {
  15.         ps->arr[i]=i;
  16.     }
  17.     for(i=0;i<5;i++)
  18.     {
  19.         printf("%d",ps->arr[i]);      
  20.     }
  21.     int *ptr=realloc(ps->arr,10*sizeof(int));
  22.     if(ptr!=NULL)
  23.         ps->arr=ptr;
  24.     for(int i=5;i<10;i++)
  25.         ps->arr[i]=i;
  26.     for(int i=0;i<10;i++)
  27.         printf("%d",ps->arr[i]);
  28.     //释放内存,注意先后顺序不能改变
  29.     free(ps->arr);
  30.     ps->arr=NULL;
  31.     free(ps);
  32.     ps=NULL;
  33.     
  34.     return 0;
  35. }

柔性数组的优点（第一种对于第二种而言的优点）

1.第二种运用了两次malloc，就要使用两次free(),出错概率更高

2.柔性数组相当于第二种方法，内存碎片更少了，内存利用率更高

3.柔性数组开辟的空间内存是连续的，访问效率更高，而第二种方法不是连续的

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/592257
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号