动态内存分配及柔性数组的实现

目录

1.malloc

2.free

3.ralloc

4.relloc

***柔性数组***

---

1.malloc

malloc-->void*malloc(size_tsize);
int* p = (int*)malloc(10*sizeof(int));// malloc函数返回的是void型
用strerror(errno)来返回错误的原因头文件#inlcude<errno.h>   记得一定要用这个检查检查
在使用动态内存时，当动态申请的空间不在使用时要释放空间-->free

2.free

free完不会指为空指针要手动弄成空的；free是用来释放动态开辟空间的；；；
注意在释放完后p还是指向那个地址所以要将p设为空指针p = NULL;

下面是简单的使用malloc和free实现开辟动态空间
 

#include<stdio.h>
#include<errno.h>
int main()
{
    //代码1
    int num = 0;
    scanf("%d",&num);
    int arr[num];
    //代码2
    int* ptr = NULL;
    ptr = (int*)malloc(num*sizeof(int));
    if(NULL = ptr)
    {
    printf("%s",strerror(errno));
    }else
    {
    int i = 0;
    for(i=0;i<num;i++)
    {
    arr[i]=i;
    *(ptr+i) = 0;
    }
    }
    free(ptr);
    ptr = NULL;
    return 0;
}

3.ralloc

void*calloc(num,sieof(int));

它和malloc一样都是在堆开辟了一块动态空间，使用地方方法目的大致相同

calloc与malloc的区别

1.参数的使用方式不同

malloc(10* sizeof(int));或者malloc(40);

calloc(10,sizeof(int));

2.malloc的使用效率较高，calloc在返回在堆区申请的那块动态内存的起始地址之前，会将每个字节都初始为0；

4.relloc

void*realloc调整动态开辟内存空间的大小//***这个要注意的点就算是可能会超出该内存的范围，则需要重新开辟新的空间，则要用新的东西来接受他。***
//如果在这里使用malloc开辟的20个字节空间
//假设这里，20个字节不能满足我们的使用了
//希望我们能有40个字节的空间
//这里就可以使用realloc来调整动态开辟的内存
//realloc使用注意事项
1.如果p指向的空间之后有足够的内存空间可以追加，则直接追加，后返回p
2.如果p指向的空间之后没有足够的内存空间可以追加，则realloc函数会重新找一个新的内存区域，开辟一块满足需求的空间，释放解旧的内存空间，最后返回新的内存地址。
3.需要用新的变量来接受 realloc
p = realloc(P,num)；

动态内存使用注意事项
1.对同一块动态内存的多次释放
2.使用free时释放动态开辟内存的一部分
//free（）是从该位置向后释放，所以说要想使用free要能确保（）里面的数的指针指的位值不变。
*（p+i）是p首位置不变但是向后不断赋值，而使用*p++则是p的地址会进行移动。
3.对动态开辟内存的忘记释放
sleep（1000）使用的头文件#include<windows.h>
while(1)
{
    amlloc(1);
}
会不断消耗你的内存你的内存会跑满，内存泄漏。
4.可能用malloc开辟不成功，则用int *p = (int*)malloc(40);p-->NULL,则直接用p=5（数字）就会出现NULL指针解引用
5.对动态开辟内存的越界访问，会报错
栈区，堆区，静态区 (static)

***柔性数组***

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

使用动态内存实现柔性数组：
 

#include<stdio.h>
struct S
{
    int n;
    int arr[0];//未知大小的-柔性数组成员-数组大小是可以调整的
};
int main()
{
    
    
    struct S*ps = (struct S*)malloc(sizeof(struct S)+5*sizeof(int));
    ps->n = 100;
    int i =0;
    for(i = 0;i<5;i++){
        ps->arr[i] = i;//0,1,2,3,4
    }
    struct S*ptr = realloc(ps,44);
    if(ptr != NULL){
        ps = ptr;
    }
    for(i=5;i<10;i++){
        ps->arr[i] = i;//56789
    }
    for(i=0;i<10;i++){
        printf("%d",ps->arr[i]);
    }
    free(ps);
    ps = NULL;
    return 0;
}
struct S
{
    int n;
    int*arr;
};
 
int main()
{
    /*开发到堆上*/struct S* p = (struct S*)malloc(sizeof(struct S));//也可以用struct S*p直接开发到栈上。 
    p->n = 100;
    p->arr = (int*)malloc(10*sizeof(int));

    return 0;
}

柔性数组优点

1.空间一次分配，可以防止内存泄漏

2.减少内存碎片化，连续分配内存

3.可以调整空间大小