C语言动态内存

动态内存空间

        空间是在堆区开辟的，开辟的大小是固定的。C语言提供了三个函数开辟动态内存的空间：malloc、calloc、realloc，还有一个函数对动态内存开辟的空间进行释放free函数。

free

        free函数对动态内存开辟的空间完成释放。如果释放的空间不是动态开辟的，是未定义行为，如果是NULL空指针，free函数什么都不做。

        当动态开辟的空间不需要使用的时候，使用free函数进行释放，将这一块动态开辟的空间还给操作系统，free函数只能对malloc、calloc、realloc返回的指针进行释放，对其它指针释放会崩溃。

        程序结束，动态申请的内存操作系统自动回收。如果程序不结束，不使用free函数释放，又不使用该空间，内存泄漏。

        free指针后，手动将指针置为NULL。

malloc

        malloc函数的功能是开辟动态内存空间，头文件是stdlib.h。malloc返回一个指向动态开辟内存的空间的指针，如果没有开辟成功返回一个NULL空指针，返回指针的类型都是void*类型的，使用需要进行强制类型转换。

        参数是开辟空间的字节大小。如果参数为0，这是未定义的行为。

        检查指针不为空指针才使用，动态内存开辟的空间使用也不要越界。

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)malloc(20);
	if (p != NULL)
	{
		for (int i = 0; i < 5; ++i)
		{
			*(p+i) = 1;
		}
	}
	free(p);
    p = NULL;
	return 0;
}

        释放动态内存开辟的空间后，指针还指向着这一块空间，不能够使用了，将该指针置为空指针，防止错误使用。

calloc

        calloc函数的功能是在堆区申请一个数组并将元素初始化为0，头文件是stdlib.h。calloc返回一个指向动态开辟内存的空间的指针，如果没有开辟成功返回一个NULL空指针，返回指针的类型都是void*类型的，使用需要进行强制类型转换。

        参数有两个，第一个是申请元素的个数，第二个是元素的字节大小。

        calloc函数会对动态内存开辟的空间进行初始化为0。

        检查指针不为空指针才使用，动态内存开辟的空间使用也不要越界。

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)calloc(5, 4);
	if (p != NULL)
	{
		for (int i = 0; i < 5; ++i)
		{
			*(p+i) = 1;
		}
	}
	free(p);
    p = NULL;
	return 0;
}

realloc

        对动态内存开辟的空间扩容。返回新动态开辟空间的指针，返回类型是void*，使用需要强制类型转换。如果扩容失败，返回一个NULL空指针。

        有两个参数，第一个参数是动态开辟空间的指针，第二个是新开辟空间的字节大小。

        realloc函数调整原内存空间大小的基础上，还会将原来内存中的数据拷贝到新的空间。如果原空间后面有足够大的空间，在后面开辟额外的空间；如果原空间后面没有足够的空间，另外找一个空间开辟，将数据拷贝到新的空间，再将原空间释放。

        检查指针不为空指针才使用，动态内存开辟的空间使用也不要越界。

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)malloc(20);
    p = (int*)realloc(p, 40)
	if (p != NULL)
	{
		for (int i = 0; i < 10; ++i)
		{
			*(p+i) = 1;
		}
	}
	free(p);
    p = NULL;
	return 0;
}

动态内存使用错误

        对NULL空指针解引用

int* p = (int*)malloc(INT_MAX);
*p = 1;

        越界访问

int* p = (int*)malloc(20);
if (p != NULL)
{
	for (int i = 0; i <= 5; ++i)
	{
		*(p+i) = 1;
	}
}

        对非动态内存开辟的空间释放

int a = 10;
free(&a);

        不是free动态开辟空间的首地址

int* p = (int*)malloc(20);
if (p != NULL)
{
	for (int i = 0; i < 3; ++i)
	{
		*p++ = 1;
	}
}
free(p);

        程序不结束，没有释放不再使用的动态内存开辟空间，以及出了这个函数无法释放的动态内存空间。

test
{
    int* p = (int*)malloc(10);
}

int main()
{
    test();
    return 0;
}

柔性数组

        结构体最后一个成员变量是没有定义大小的数组，这个数组叫做柔性数组。

struct A
{
    int a;
    int arr[];
    // int arr[0]; 也可以写成这种格式
};

柔性数组的特点

        该结构体至少有其它一个成员变量。

        sizeof计算含有柔性数组的结构体大小，不包含柔性数组。

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

        20字节是为柔性数组开辟的空间，arr数组有5个元素。

柔性数组的优势

        方便释放，不使用柔性数组需要释放两次。

#include <stdio.h>
#include <stdlib.h>
struct A
{
	int a;
	int *parr;
};

int main()
{
	printf("%d\n", sizeof(struct A));
	struct A* p = (struct A*)malloc(sizeof(struct A));
	p->parr = (int*)malloc(20);
	free(p->parr);
	free(p);
	p = NULL;
	return 0;
}

        减少内存碎片，结构体其它成员变量跟柔性数组连续存储，连续的内存提高访问速度。不使用柔性数组，两次malloc是两块不同的空间，不会开辟连续的空间。