动态内存管理

目录

malloc

返回栈空间地址问题： 

 free

calloc

realloc

内存开辟

柔性数组

优点

---

malloc

void* malloc(size_t size)

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

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

malloc失败导致对空指针解引用：   

int *p = (int*)malloc(INT_MAX);
*p = 5;
free(p);
p = NULL;

记得返回动态开辟的空间地址，别忘了最后释放空间避免内存泄露：

int* get_memory()//也可使用二级指针
	int* p = (int*)malloc(40);
	//....
	return p;
}
int main()
{
int *ptr = get_memory();
	//使用
 
	//释放
	free(ptr);
	ptr = NULL;
 
	return 0;
}

返回栈空间地址问题： 

char* Getmemory()
{
	const char* a = "hello";//存放在常量区返回后地址还在
	return (char*)a;
}
char* Getmemory()
{
	char a[] = "hello";//栈区空间返回后被销毁
	return a;
}
int main()
{
	char* p = Getmemory();
	printf("%s", p);
return  0;
}

int* test()
{
	int a = 10;
	return &a;
}
 
int main()
{
	int*p  = test();
	//printf("hehe\n");
	printf("%d\n", *p);
 
	return 0;
}

这段代虽然访问了被销毁的空间，但依然能正确输出，这可能是由于编译器并未对数据进行清理的缘故，依然是一段错误代码，当你在打印前加上个printf函数，它开辟的栈帧会建立在销毁的test函数上，可能就导致数据被篡改了。

 free

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

• 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
• 如果参数 ptr 是NULL指针，则函数什么事都不做。

int* p = (int*)malloc(40);
	if (p == NULL)
		return 1;
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*p = i;
		p++;
	}
	//释放
	//在释放的时候，p指向的不再是动态内存空间的起始位置
	free(p);
	p = NULL;

 注意释放时需要记录起始位置的地址。

calloc

void* calloc(size_t num, size_t size)

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

realloc

void* realloc(void *ptr, size_t size)

对已经动态开辟的空间进行扩容(缩容），如果第一个参数为NULL则作用类似于malloc。

如果扩容失败则返回NULL，所以扩容前最好将原地址保存起来。

内存开辟

柔性数组

在c99中，结构体的最后一个成员可以设置成柔性数组（否则不知道对齐数）。

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

 有些编译器会报错无法编译可以改成： 

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

• 结构中的柔性数组成员前面必须至少一个其他成员。（结构体大小是编译时分配，而柔性数组是动态开辟的）
• sizeof 返回的这种结构大小不包括柔性数组的内存。
• 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

 使用柔性数组:

	struct S* ps = (struct S*)malloc(sizeof(struct S) + sizeof(int) * 4);//连续开辟
	if (ps == NULL)
		return 1;
	ps->n = 10;
	ps->s = 5.5f;
	for (int i = 0; i < 4; i++)
	{
		scanf("%d", &ps->arr[i]);
	}
	struct S*ptr = (struct S*)realloc(ps, sizeof(struct S)+10*sizeof(int));
	if (ptr == NULL)
	{
		return 1;
	}
	else
	{
		ps = ptr;
	}
	free(ps);
	ps = NULL;
    return 0;
}

使用指针：

struct S
{
	int n;
	float s;
	int *arr;//指针——>动态开辟
};
int mian()
{
struct S*ps = (struct S*)malloc(sizeof(struct S));
if (ps == NULL)
	return 1;
		
ps->n = 100;
ps->s = 5.5f;
			
int* ptr = (int*)malloc(4 * sizeof(int));
	if (ptr == NULL)
		{
			return 1;
		}
	else
		{
		    ps->arr = ptr;
		}
	//使用
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		scanf("%d", &(ps->arr[i]));
	}
    realloc(ps->arr, 10*sizeof(int));
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;
}

优点

首先，在内存分配中，连续分配的内存有利于减少内存碎片，提高访问速度。

其次，当你在函数中对结构体及其指针成员进行两次动态分配后，可能会只释放了结构体而忘了释放成员在堆上开辟的空间，造成内存泄露。