1.为什么要有动态内存分配
int i = 20;//在栈空间上开辟四个字节
char arr[10] = { 0 };//在栈空间上开辟十个字节的连续空间
上述开辟空间的方式有连个特点:
(1)空间开辟大小时确定的
(2)数组在申明时必须指定数组的长度,数组空间一旦确定了大小就不能调整
而C语言引入的动态内存开辟让程序员自己可以申请和释放空间
2.malloc和free
2.1malloc
malloc是C语言提供的一个动态内存函数。包含在stdlib.h文件中,函数原型如下:
void* malloc (size_t size);
该函数向内存申请一块指定大小连续可用的空间,并返回指向这块空间的指针。
(1)如果开辟成功,则返回⼀个指向开辟好空间的指针
(2)如果开辟失败,则返回⼀个NULL 指针,因此malloc的返回值⼀定要做检查。
(3)返回值类型是void*,所以malloc函数并不知道开辟空间的类型,具体在使用的时候使用者自己来决定。
(4) 如果参数 size 为0,malloc的行为是标准是未定义的,取决于编译器。
(5)使用 malloc 分配的内存空间不会自动进行初始化,其内容是未定义的。在使用完动态分配的内存后,需要使用 free 函数释放,以避免内存泄漏。内存泄漏是指程序在运行过程中不断地分配内存但未释放,导致可用内存逐渐减少,最终可能影响程序的正常运行。
int main()
{
int* p = (int*)malloc(20);//开辟20个字节的空间
if (p == NULL)
{
perror(malloc);//输出错误信息
return 1;
}
int i = 0;
for (i = 0; i < 5; i++)
{
*(p + i) = i;
printf("%d ", p[i]);//0 1 2 3 4
}
return 0;
}
2.2free
void free (void* ptr);
free 函数也是 C 语言标准库中的函数,用于释放由 malloc 、 calloc 或 realloc 函数分配的动态内存空间。
使用 free 函数的主要作用在于及时回收不再使用的内存,防止内存泄漏。
当使用 free 释放内存后,该内存空间将被标记为可重新分配,但指针 ptr 本身并不会被修改或自动设置为 NULL ,为避免后续对已释放内存的非法访问,通常建议在释放后将指针置为 NULL 。
(1)参数 ptr 是要释放的内存块的指针,该指针必须是先前通过动态内存分配函数(如 malloc 等)获取的有效指针,如果指向的空间不是动态内存开辟的,则free的行为是未定义的。
(2)如果参数ptr是NULL指针,则函数什么事都不做
#include <stdio.h>
#include <stdlib.h>
int main()
{
; int i = 0;
int arr[10] = { 0 };
int* ptr = (int*)malloc(10 * sizeof(int));
if (ptr != NULL)
{
for (i = 0; i < 10; i++)
{
*(ptr + i) = i;
printf("%d ", ptr[i]);
}
}
free(ptr); //释放ptr所指向的动态内存
for (i = 0; i < 10; i++)
{
printf("%d ", ptr[i]);
}
ptr = NULL;
return 0;
}
3.calloc和realloc
3.1calloc
calloc也是C语言中的一个动态内存分配函数,原型如下:
void* calloc (size_t num, size_t size);
(1)函数的功能是在内存的动态存储区中分配 num 个大小为 size 的连续空间,并且把空间的每个字节初始化为0。
(2) 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0
int main()
{
int* p = (int*)calloc(10, sizeof(int));
if (NULL != p)
{
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));//0 0 0 0 0 0 0 0 0 0
}
}
free(p);
p = NULL;
return 0;
}
3.2realloc
realloc函数用于重新调整之前通过 malloc 、 calloc 或 realloc 分配的内存块的大小。其原型通常为
void *realloc(void *ptr, size_t size);
(1)ptr是指向要调整大小的内存块的指针, size 是新的大小(以字节为单位)。
(2) realloc 函数的作用包括:
1. 扩大内存块:如果新的大小大于原来的大小, realloc 会尝试在原内存块的基础上扩展,如果后面有足够的可用空间,就直接扩展并返回原指针;如果没有足够的连续空间,会重新分配一块新的更大的内存,并将原内存块中的内容复制到新的内存块中,然后释放原内存块,返回新内存块的指针。
2. 缩小内存块:如果新的大小小于原来的大小, realloc 会缩小内存块,并保留原内存块中前面 size 字节的内容,多余的部分被释放。
(3)使用 realloc 时需要注意返回值,如果重新分配内存成功,返回值为调整之后的内存起始位置。如果失败(例如内存不足),则返回 NULL ,并且原内存块不会被释放。
(4)使用 realloc 分配或调整大小后的内存,在不再使用时也需要使用 free 函数进行释放。
int main()
{
int* p = (int*)malloc(5 * sizeof(int));
if (p == NULL)
{
perror(malloc);
return 1;
}
int i = 0;
for (i = 0; i < 5; i++)
{
*(p + i) = i;
printf("%d ", p[i]);//0 1 2 3 4
}
printf("\n");
//将内存调整为40个字节
int* ptr = (int*)realloc(p, 40);
if (NULL != ptr)
{
p = ptr;
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
printf("%d ", *(p + i));//0 1 2 3 4 5 6 7 8 9
}
free(p);
p = NULL;
}
else
{
perror(ptr);
}
return 0;
}
4.常见动态内存的错误
(1)对NULL的解引用操作
int main()
{
int* p = (int*)malloc(20);
p = 20;//如果内存开辟失败,p是空指针,就会有问题
free(p);
return 0;
}
正确示例:
int main()
{
int* p = (int*)malloc(20);
if (p = NULL)
{
perror(p);
return 1;
}
p = 20;
free(p);
return 0;
}
(2)动态开辟空间的越界访问
int main()
{
int i = 0;
int* p = (int*)malloc(10 * sizeof(int));
if (p = NULL)
{
perror(p);
return 1;
}
for (i = 0; i <= 10; i++)
{
*(p + i) = i;
printf("%d ", *(p + i));//当i是10时越界访问
}
free(p);
return 0;
}
(3)对非动态靠皮内存使用内存释放
int main()
{
int n = 1;
int* p = &n;
free(p);//free用来释放动态内存空间
return 0;
}
(4)使用free释放动态开辟内存的一部分
int main()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
*p = i;
p++;
}
free(p);//此处的动态开辟内存的起始位置
p = NULL;
return 0;
}
(5)对同一块内存多次释放
int main()
{
int* p = (int*)malloc(100);
free(p);
free(p);
return 0;
}
(6)动态开辟内存忘记释放(内存泄漏)
test()
{
int* p = (int*)malloc(100);
if (p != NULL)
{
*p = 20;//内存不释放,while不断循环,不断占用内存
}
}
int main()
{
test();
while (1);
return 0;
}
5.柔性数组
C99中,结构中的最后⼀个元素允许是未知大小的数组,这就叫做”柔性数组“成员。
柔性数组(Flexible Array)是指在结构体的末尾定义一个长度不定的数组。它之所以被称为“柔性数组”,主要是因为其具有一定的灵活性和特殊性。当结构体所包含的数据长度不固定,或者需要在分配结构体内存时根据实际情况动态确定数组的大小时,柔性数组可以避免额外的内存分配和指针操作,提高程序的性能和效率,通过动态存储函数设置结构体的大小,即可改变结构体最后一个元素的大小,这也是“柔性”的来源。
//两种方式
typedef struct type_st
{
int i;
int arr[];//柔性数组成员
}type;
typedef struct type_st
{
int i;
int arr[0];//柔性数组成员
}type;
(1)柔性数组的特点
结构中的柔性数组成员前面必须至少⼀个其他成员。
sizeof返回的这种结构大小不包括柔性数组的内存。
typedef struct type_st
{
int i;
int arr[];//柔性数组成员
}type;
int main()
{
printf("%d\n", sizeof(type));//4
return 0;
}
包含柔性数组成员的结构用malloc()函数进行内存的动态分配,并且分配的内存应该大于结构的大 小,以适应柔性数组的预期大小。
typedef struct type_st
{
int i;
int arr[];//柔性数组成员
}type;
int main()
{
int i = 0;
type* p = (type*)malloc(sizeof(type) + 100 * sizeof(int));
p->i = 100;
for (i = 0; i < 100; i++)
{
p->arr[i] = i;
}
free(p);
return 0;
}
(2)柔性数组的优势
struct S
{
int i;
int arr[];//柔性数组成员
};
int main()
{
int i = 0;
struct S* p = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int));
if (p == NULL)
{
perror(p);
return 1;
}
for (i = 0; i < 5; i++)
{
p->arr[i] = i;
}
//调整内存
struct S* ptr = (struct S*)realloc(p, sizeof(struct S) + 10 * sizeof(int));
if (ptr != NULL)
{
p = ptr;
}
free(p);
p = NULL;
return 0;
}
使用柔性数组有两个好处:
第⼀个好处是:方便内存释放。如果我们的代码是在⼀个给别人用的函数中,你在里面做了⼆次内存分配,并把整个结构体返回给用户。用户调用free可以释放结构体,但是用户并不知道这个结构体内的成员也需要free,所以你不能指望用户来发现这个事。所以,如果我们把结构体的内存以及其成员要的内存⼀次性分配好了,并返回给用户⼀个结构体指针,用户做⼀次free就可以把所有的内存也给释放掉。
第⼆个好处是:这样有利于访问速度. 连续的内存有益于提高访问速度,也有益于减少内存碎片。