动态内存管理

一:为什么要有动态内存分配

创建数组或定义变量时空间开辟的大小是固定的.

数组在申明是，必须指定数组的长度，数组空间一旦确定就不能调整了

但是，对于空间的需求，有时需要空间大小在程序运行时才知道,所以数组编译时开辟的空间方式就不满足了,因此C语言引入了动态内存开辟,让程序员可以申请和释放空间,比较灵活.

malloc,free,calloc和realloc都定义在头文件<stdlib.h>

二:malloc和free

1.malloc

C语言提供了一个动态内存开辟的函数:

void *malloc (size_t size);

malloc函数向内存申请一块连续可用的空间(单位字节),并返回指向这块空间的指针

1.如果开辟成功,则返回指向开辟好的空间的指针

2.开辟失败,则返回NULL指针,因此malloc的返回值一定要做检查

3.但是,malloc只知道申请多大的空间,不知道返回的类型,因此它只能返回void *,所以在返回时可以将malloc强制类型转换再赋给相应类型的指针

4.如果size为0,malloc的行为标准时未定义的,取决于编译器

malloc申请的空间在内存的堆区(局部变量,函数参数等放在栈区)

对于malloc申请的空间的赋值eg:

for(int i = 0;i < 10;i++)
{
    *(p + i) = i;
}

2.free

free函数用于动态内存的释放和回收:

void free(void *ptr);

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

1.如果参数ptr指向的空间不是动态开辟的,那么free函数的行为是未定义的

2.如果参数ptr是NULL指针,那么函数什么都不做

当然,为了避免指针变为野指针,在调用free后要将指针变为空指针

三:calloc和realloc

1.calloc

calloc也用来动态内存分配

void calloc (size_t num,size_t size);

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

2.与malloc的区别在于calloc会在返回地址之前把申请的空间的每一个字节初始化为0,其余与malloc基本相同

2.realloc

realloc函数然动态内存管理更灵活,realloc函数可以对动态开辟内存大小的调整

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

第一个参数是要改变的空间的指针,第二个参数是修改的大小

1.realloc调整空间失败时,会返回NULL

2.调整成功时,存在两种情况:

? ? ? ? (1).在已经开辟好的空间后面没有足够的空间,则realloc函数会在内存的堆区重新找一块空间(满足新的空间大小的需求),同时把旧的数据拷贝到新的空间,然后释放旧的空间,同时返回新的空间的起始地址

? ? ? ? (2).反之,则在已有空间后面直接进行扩大,并直接返回旧的空间的起始地址.

当然,最好不要直接用原指针接收realloc的返回值(防止空间开辟失败导致原本的指针的丢失),为了防止开辟新空间失败,最好创建一个新的指针来接受返回值.

四.常见的动态内存的错误

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

int main()
{
    int *p = (int *)malloc(100);
    *p = 20;//p可能是空指针
    return 0;
}

因此要添加判断语句

if(p == NULL)
{
    perror("malloc");
    return 0;
}

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

int main()
{
    int *p = (int *)malloc(10)
    if(p == NULL)
    {
        return 1;
    }
    int i = 0;
    for(i = 0;i <= 10;i++)
    {
        *(p + i) = i;//循环到第十一次时发生越界访问
    }
}

3.对非动态内存的free释放

4.使用free释放一块动态内存的部分

int  main()
{
    int a = 0;
    int *p  = (int *)malloc(40);
    if(p == NULL)
    {
        return 1;
    }
    ++p;//此时p不再指向起始位置,而是前进了一步,导致free不能够完全释放的内存
    free(p);
    p = NULL;
    return 0;
}

5.对同一块动态内存的多次释放

?6.动态内存忘记释放(内存泄漏)

五.柔性数组

在C99中,结构体中的最后一个元素允许时未知大小的数组,这个数组就叫做"柔性数组"

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

1.柔性数组的特点

1.结构体的柔性数组成员前至少有一个其他成员

2.sizeof返回的这种结构体的大小不包含柔性数组的内存

3.包含柔性数组成员的结构体用malloc函数进行动态内存分配,且分配的内存应大于结构体的大小,以适应柔性数组的大小

2.柔性数组的使用

eg.

struct st
{
    cha c;
    int n;
    int arr[];
};

int main()
{
    struct st *ps = (struct st*)malloc(sizeof(struct st) + 10*sizeof(int));
    if(ps == NULL)
    {
        perror("malloc");
        return 1;
    }

    ps->c = 'w';
    ps->n = 100;
    int i = 0;
    for(i = 0;i < 10;i++)
    {
        ps->arr[i] = i;
    }
//如果数组空间不够
    struct st *ptr = realloc(ps,sizeof(struct st) + 15*sizeof(int));

    if(ps != NULL)
    {
        ps = ptr;
    }
    else
    {
        perror("realloc");
        return 1;
    }

//释放
    free(ps);
    ps = NULL;

    return 0;
}

3.柔性数组的优势

1.方便内存释放

2.有利于访问速度