动态内存分配(malloc,calloc,realloc)和柔性数组

1.为什么使用动态内存分配

在声明数组时，必须用一个编译时常量指定数组的长度，但是，数组的长度常常在运行时才知道，这是因为它所需要的内存空间取决于输入数据。例如，一个用于计算学生等级和平均分的程序可能需要存储一个班级所有学生的数据，但不同班级的学生数量可能不同。在这种情况下，我们就可以尝试一下动态内存开辟了。

2.malloc和free

malloc 函数原型 :

void* malloc (size_t size); 

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

(1).如果开辟成功，则返回一个指向开辟好空间的指针。

(2).如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。

(3). 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。

(4).如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

free函数原型 :

void free (void* ptr);

free函数用来释放动态开辟的内存。

(1).free函数释放的是ptr指针所指向的空间，释放完后 ptr 仍然指向被释放的空间，所以释放完空间后记得将 ptr 指针置为 NULL

(2). 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。

(3). 如果参数 ptr 是NULL指针，则函数什么事都不做。

#include <stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = NULL;
	ptr = (int*)malloc(num * sizeof(int));
	// 判断ptr指针是否为空
	if (ptr != NULL)
	{
		int i = 0;
		for (i = 0; i < num; i++)
		{
			*(ptr + i) = 0;
		}
	}
	free(ptr);
	ptr = NULL;
	return 0;
}

3.calloc和realloc

calloc 函数原型 :

void* calloc(size_t num_elements,size_t element_size);

calloc 也用于分配内存

函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。

malloc 和 calloc 之间的主要区别是后者在返回指向内存的指针之前把它初始化成0.

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (p != NULL)
	{
		// 使用空间
	}
	free(p);
	p = NULL;
}

realloc 函数原型 :

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

realloc 函数用于修改一个原先已经分配的内存块的大小，使用这个函数，可以使一块内存扩大或缩小，如果用于扩大一个内存块，存在两种情况

情况1 ： 原有空间之后有足够的空间

这块内存原先的内容依然保留，新增加的内存添加到原先内存块的后面，新内存并未以任何方式进行初始化

情况2 ： 原有空间之后没有足够大的空间

realloc 函数将分配另一块正确大小的内存，并将原先那块内存的内容复制到新的块上，并释放原来的空间

如果用于缩小一个内存块，该内存块尾部的部分内存便被拿掉，剩余部分内存的原先内容依然保存

最后，如果 realloc 函数的第一个参数为 NULL,那么它的行为就和 malloc 一样,开辟一块 new_size大小的空间

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

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

(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);
   //重复释放 
}

(6).动态开辟内存忘记释放

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

5.柔性数组

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

typedef struct st_type
 {    
     int i;
     int a[]; //柔性数组成员 
 }type_a;

柔性数组的特点：

(1). 结构中的柔性数组成员前面必须至少一个其他成员。

(2). sizeof 返回的这种结构大小不包括柔性数组的内存。

(3). 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应 柔性数组的预期大小。

例 : sizeof 计算包含柔性数组成员的结构体大小

#include<stdio.h>
struct FlexArray
{
	int n;     // 4字节  对齐数为4
	char c;    // 1字节  对齐数为1
	int arr[]; // 柔性数组成员
};
int main()
{
	printf("%d\n", sizeof(struct FlexArray));
}

// 打印结果为 8 

根据前文所讲的 结构体及内存对齐 可知计算结果为 8

例 : 柔性数组的使用

#include<stdio.h>
#include<stdlib.h>
typedef struct FlexArray
{
	int i;
	int arr[]; // 柔性数组成员
}FlexArray;
int main()
{
	FlexArray* pF = (FlexArray*)malloc(sizeof(FlexArray) + 10 * sizeof(int));
	pF->i = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		pF->arr[i] = i;
	}
	free(pF);
	pF = NULL;
}

这样，柔性数组成员 arr 就获得了10个连续的整形空间,结构如下

当然我们可能也会写出如下的代码，那这样写和柔性数组哪个更好呢?

#include<stdio.h>
#include<stdlib.h>
typedef struct S
{
	int n;
	int* arr;
}s;
int main()
{
	s* ps = (s*)malloc(sizeof(s));
	ps->arr = (int*)malloc(sizeof(int) * 10);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;
}

上述两段代码的功能是一样的，但使用柔性数组的方式有两个好处 :

(1). 方便内存释放

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用 户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发 现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体 指针，用户做一次free就可以把所有的内存也给释放掉

(2). 有利于访问速度

连续的内存有益于提高访问速度，也有益于减少内存碎片。