c语言中动态内存管理

说到内存，大家一定都知道。但是有一种函数可以实现动态内存管理，下面大家一起学习。

文章目录

• 一、为什么要有动态内存管理？
• 二、malloc 和 free
• • 1.malloc
  • 2.free
  • 三、calloc 和 realloc
  • • 1.calloc
    • 2.realloc
    • 3.常见的动态内存的错误
    • • 3.1对NULL指针的解引用错误
      • 3.2对动态开辟空间的越界访问
      • 3.3对非动态开普内存使用free释放
      • 3.4 使用free释放一块动态开辟内存的一部分。
      • 3.5 对同一块动态内存多次释放。
      • 3.5 动态开辟内存忘记释放（内存泄漏）
      • 4.经典笔试题分析
      • • 4.1
        • 4.2
        • 4.3
        • 4.4
        • 四、柔性数组
        • • 1.柔性数组的特点
          • 2.柔性数组的使用

            ---

            一、为什么要有动态内存管理？

            经过c语言的学习，相信大家都知道如何开辟一块内存。

            int i = 6;
            int arr[10]={0};
            

            上面代码开辟的空间，有两个特点：

            1. 空间开辟大小是固定的。
            2. 数组在申明的时候必须指定数组的长度，数组空间一旦确定大小就不能调整了。

            这时候我们会发现当我们写代码的时候，我们需要开辟多少空间在程序运行的时候才能知道。这时候就需要引入动态内存开辟了，让程序员自己申请和释放空间。

            二、malloc 和 free

            1.malloc

            void* malloc (size_t size);
            

            这个函数向内存申请一开连续可用的空间，并返回指向这块空间的指针。

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

            

            这个代码用了malloc函数申请空间，先是申请了20个字节的空间强制转换为整形变为存放5个整数。

            2.free

             void free (void* ptr);
            

            函数free，是专门用来给动态内存的释放和回收的。

            1. 如果参数ptr指向的空间不是动态开辟的，那么free函数的行为毫无意义。
            2. 如果参数ptr是NULL指针，则函数什么事都不做。

            #include 
            #include 
             int main()
             {
             	int num = 0;
             	scanf("%d", &num);
             	int arr[num] = {0};
             	int* ptr = NULL;
             	ptr = (int*)malloc(num*sizeof(int));
             	if(NULL != ptr)//判断ptr指针是否为空
             {	
            	int i = 0;
             	for(i=0; i
             		*(ptr+i) = 0；
             	}
             }
             
             free(ptr);/释放ptr所指向的动态内存
             
            ptr = NULL;//是否有必要？
             
            return 0;
             }
            
            	 int *p = (int *)malloc(INT_MAX/4);
             	 *p = 20;
             	 free(p);
             }
            
            	 int i = 0;
             	 int *p (int*)malloc(10*sizeof(int));
             	if(NULL == p)
             	{
             		exit(EXIT_FAILURE);
             	}
             	for(i=0; i 
             		*(p+i) = i;
             	}
            	 free(p);
             }
            
            		int a =10;
            		int* p=&a;
            		free(p);
            	}
            
             	int *p = (int *)malloc(100);
            	p++;
             }
             	free(p);
            
             	int *p = (int *)malloc(100);
             	free(p);
             	free(p);//重复释放
             
            }
            
             	int *p = (int *)malloc(100);
             	if(NULL != p)
             {
             	*p = 20;
             }
             }
             	int main()
             {
             	test();
             	while(1);
             }
            
             	p = (char *)malloc(100);
             }
             void Test(void)
             {
             	char *str = NULL;
             	GetMemory(str);
            	strcpy(str, "hello world");
             	printf(str);
             }
            
            	char p[] = "hello world";
             	return p;
             }
             void Test(void)
             {
             	char *str = NULL;
             	str = GetMemory();
             	printf(str);
             }
            
             	*p = (char *)malloc(num);
             }
             	void Test(void)
             	{
             		char *str = NULL;
             		GetMemory(&str, 100);
             		strcpy(str, "hello");
             		printf(str);
             	}
            
             	char *str = (char *) malloc(100);
             	strcpy(str, "hello");
             	free(str);
             	if(str != NULL)
             	{
             		strcpy(str, "world");
             		printf(str);
             	}
             }
            
             int i;
             int a[];//柔性数组成员
             
            };
            
            	int n;//4
            	int arr[];
            };
            int main()
            {
            	
            	struct S* ps = (struct S*)malloc(sizeof(struct S) + 5*sizeof(int));
            	if (ps == NULL)
            	{
            		perror("malloc");
            		return 1;
            	}
            	ps-n = 100;
            	int i = 0;
            	for (i = 0; i  
             
             
            到这里动态内存管理基本就结束了，大家如果有问题可以一起讨论。谢谢大家！