[C/C++]C语言内存开辟，回收及柔性数组

以前使用的静态存储方式开辟空间如：

	int vvv = 100;
	char arrr[20];

这种方式的空间开辟大小是固定的。而且数组在申明的时候，要指定数组的长度。但是有时需要的空间大小在程序运行的时候才能知道。这时就应该使用动态内存开辟。

一、动态内存函数的介绍

        1.malloc

           C语言提供了一个动态内存开辟的函数，在stdlib.h 头文件中。函数原型如下：

void* malloc (size_t size);

           这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。size -- 内存块的大小，以字节为单位,

                   1.此函数的返回值是分配区域的起始地址，或者说，此函数是一个指针型函数，返回的指针指向该分配域的开头位置。如果分配成功则返回指向被分配内存的指针)，否则返回空指针NULL。当内存不再使用时，应使用free()函数将内存块释放。

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

        2.free

           对应malloc，C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的，在stdlib.h 头文件中。函数原型如下：

void free (void* ptr);

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

          举个malloc和free的例子：

void TEST1()
{
	int num = 0;
	scanf("%d",&num);

	int* ptr = NULL;
	ptr = (int*)malloc(num * sizeof(int));
	if (ptr != NULL)
	{
		int i = 0;
		for (i = 0; i < num; i++)
		{
			*(ptr + i) = 0;
		}
	}
	free(ptr);
	ptr = 0;
}

        3.calloc

           C语言还提供了一个函数叫calloc ， calloc 函数也用来动态内存分配。malloc 和 calloc 之间的不同点是，malloc 不会设置内存为零，而 calloc 会设置分配的内存为零。num -- 要被分配的元素个数，size -- 元素的大小,原型如下：

void* calloc (size_t num, size_t size);

           函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0。与函数malloc 的区别只在于calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

void TEST2()
{
	int* p = NULL;
	p = (int*)calloc(10, sizeof(int));
	if (p != NULL)
	{
		//使用空间
	}
	free(p);
	p = 0;
}

         内存如图：

                      

           所以如果我们对申请的内存空间的内容要求初始化，就使用calloc函数来完成任务。

        4.realloc

         让动态内存管理更加灵活,  重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小。

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

         realloc在调整内存空间的是存在两种情况：

                 

         举个例子：

void TEST3()
{
	int* p = NULL;
	p = (int*)malloc(100);
	if (p != NULL)
	{
		//使用空间
	}
	else
	{
		exit(EXIT_FAILURE);
	}

	int* ptr = NULL;
	ptr = (int *)realloc(p,100);
	if (ptr != NULL)
	{
		p = ptr;		//指针要还给p
	}
	free(p);
	p = NULL;
}

二、常见的动态内存错误

       1.对NULL指针的解引用操作

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

        如果p的值是NULL，就会有问题，需要判断是否为空指针。

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

void TEST4()
{
	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);
	p = NULL;
}

           当i是10的时候越界访问。

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

void test()
{
int a = 10;
int *p = &a;
free(p);//o错误
}

      这样是错误的

      4.使用free释放一块动态开辟内存的一部分，对同一块动态内存多次释放，动态开辟内存忘记释放（内存泄漏），忘记释放不再使用的动态开辟的空间会造成内存泄漏。都是常见的错误。

三、C/C++程序的内存开辟

       C/C++程序内存分配的几个区域：

                                                          1.    栈区：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。 放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

                                                          2.    堆区：一般由程序员分配释放，程序结束时可能由OS回收 。

                                                          3.    数据段（静态区）（static）存放全局变量、静态数据。

                                                          4.    代码段：存放函数体的二进制代码

                                如图：            

四、柔性数组

       柔性数组是比较少见到的一个概念，柔性数组成员（flexible array member）也叫伸缩性数组成员，这种代码结构产生于对动态结构体的需求。

       定义：

typedef struct Stc
{
	int i;
	int arr[];
};

    特点：结构中的柔性数组成员前面必须至少一个其他成员。 sizeof 返回的这种结构大小不包括柔性数组的内存。包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

    柔性数组的使用：

Stc *s = (Stc*)malloc(sizeof(Stc) + 100 * sizeof(int));

s->i = 100;
for(i=0; i<100; i++)
{
p->a[i] = i;
}s