【动态内存管理】malloc&calloc和realloc和笔试题和柔性数组

0 为什么存在动态内存管理？

char str[20]={0];
int arr[20]={0};

上述的空间开辟的方式有两个特点：

1. 空间开辟空间的大小是固定的
2. 数组在申明的时候必须指定数组空间的大小，它在编译时分配所需要的内存

但是如果我们所需要的空间大小在程序编译时并不确定，而是到程序运行起来的时候才能知道，那上述的空间开辟的方式就不适合了，动态内存管理就应运而生。

定义局部变量开辟的内存和动态内存开辟的内存的区别：

• 开辟空间的位置:
• 定义局部变量开辟的空间:栈上随机位置
• 动态申请的空间: 堆上连续位置
• 释放：
• 定义局部变量开辟的空间：出代码块自动销毁
• 动态申请的空间：最好是程序员手动释放

1 malloc函数

函数原型:void malloc(size_t size)*

参数说明:size为要分配内存空间的大小，单位是字节

#include<stdio.h>
#include<stdlib.h>
#include<limits.h>
int main()
{
    //函数原型:void* malloc(size_t size)
    //向内存申请了40个字节的空间：
    //如果申请成功返回这块空间的首地址
    //如果申请失败返回空指针NULL
    int* p1 = (int*)malloc(40);//这个开辟成功
    int* p2 = (int*)malloc(INT_MAX+1);//这个开辟失败
    //后面使用这块空间时会改变p的指向，所以用ptr保留这块空间的起始地址
    int* ptr = p1;
    //检验指针p的有效性：检测内存申请结果的返回值是否为NULL
    if (p· == NULL)
    {
        perror("malloc");//malloc: Not enough space
        exit(-1);
    }
    //开辟了40个字节，也就是10个int类型变量的大小
    for (int i = 0; i < 10; i++)
    {
        *(p·++) = 0;
    }
    //释放ptr指针所指向的那块空间，但是ptr仍然保留着动态申请的那块空间的起始地址
    free(ptr);
    //让ptr指向空，使他失去对动态申请的那块空间的起始地址的记忆
    ptr = NULL;

    p=NULL;
    return 0；
}

当我们不手动释放动态内存开辟的空间：

• 如果程序结束，动态申请的内存由OS自动回收
• 但是如果程序始终不结束，动态内存申请的那块空间不会自动释放，就会造成内存泄漏问题。 (程序结束肯定会自动释放动态申请的内存，不然内存肯定会越写越少，谁还敢写代码；但是当这块空间占用的时间太长，而且这块空间开辟的比较大，就会比较吃内存）

2 calloc函数

函数原型:void calloc(size_t num,size_t size)*

参数说明：num是要分配size字节大小的空间的元素个数

malloc 和 calloc 的区别： calloc在申请内存空间的同时将这块空间初始化为0了

int main()
{
    //函数原型: void* calloc(size_t num,size_t size)
    //元素个数:10
    //每个元素所占的字节数:sizeof(int)
    int* p = (int*)calloc(10, sizeof(int));
    int* ptr = p;
    if (p == NULL)
    {
        perror("calloc");
        exit(-1);
    }
    for (int i = 0; i < 10; i++)
    {
        printf("%d\t", *(p++));
    }
    free(ptr);
    ptr = NULL;
    p = NULL;
}

3 realloc函数

有了realloc函数，我们就可以已经malloc或calloc开辟好且对容量不满意的空间进行重新调整。（调整:调大调小均可）

重新分配内存空间函数:void realloc(void ptr,size_t size)**

参数说明:ptr为指向那块需要重新分配内存空间的那块空间，size为需要重新分配的空间大小，单位是字节。

下面以扩容为例：

int main()
{
    int* p = (int*)malloc(40);
    if (p == NULL)
    {
        perror("malloc");
        exit(-1);
    }
    for (int i = 0; i < 10; i++)
    {
        *(p + i) = i;//p没有改变指向
    }
    //希望放20个元素，空间不够，考虑用realloc扩容
    int p = (int*)realloc(p, 80);//error，万一realloc扩容失败，p接收到的是空指针，把原来p的指向覆盖（弄丢）了

    //函数原型:void* realloc(void* ptr,size_t size)
    //ptr:一个指针，指针指向的是扩容的空间的起始地址
    //size:扩容成功后希望得到的字节数
    int* temp = (int*)realloc(p, 80);//bingo
    if (temp != NULL)
    {
        p = temp;
    }
    free(p);
    p = NULL;

    return 0;
}

realloc调整空间：

1. 如果要缩小空间:则在原空间上截取相应长度的空间，并返回原的首地址（也就是等于p）
2. 如果是扩大空间，分以下3种情况：

• 如果原空间在内存中的位置能够开辟出扩容后的所需要的空间大小，就相应开辟，并返回新空间的起始地址。
• 如果原空间在内存中的位置不能够开辟出扩容后所需要的空间大小，OS就会在堆内存中找一块足够容纳所需空间大小的一块新空间，将原空间里的值复制到新空间，并返回新空间的起始地址
• 如果在堆内存中的任意位置都不够开辟所需要的内存空间大小，则返回空指针。

4 常见的动态内存错误

    int main()
    {
        //way1:对NULL指针进行解引用
        int* p = (int*)malloc(INT_MAX + 1);
        //直接使用//error

        //way2:越界访问
        int* p = (int*)malloc(40);
        if (p == NULL)
        {
            perror("malloc");
            exit(-1);
        }
        for (int i = 0; i < 11; i++)//error
        {
            *(p + i) = i;
        }

        //way3:使用free函数释放非动态申请的内存
        int a = 10;
        int* p = &a;
        free(p);//error
        p = NULL;

        //way4:使用free函数释放动态申请的内存的一部分
        int* p = (int*)malloc(40);
        if (p == NULL)
        {
            perror("malloc");
            exit(-1);
        }
        for (int i = 0; i < 11; i++)//error
        {
            *p = i;
            p++;
        }
        free(p);//error
        p = NULL;

        //way5:对同一块动态申请的内存多次释放
        free(p);
        free(p);
        p = NULL;

       //way6:忘记释放动态申请的内存

        return 0;
    }

5 2道经典的笔试题：

笔试题1：下面代码能打印出hello world吗？------>传值和传址

//错误代码:
void Getmory(char* p)
{
    p = (char*)malloc(100);
}

void test(void)
{
    char* str = NULL;
    Getmory(str);
    strcpy(str, "hello world");
    printf(str);
}

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

}

答案：不能，按照代码本意：想通过Getmory函数给str动态开辟一段100个字节的空间，然后使用strcpy函数拷贝字符串‘hello world’并打印出来。

问题在于：Getmory函数的函数参数只是字符指针str的一份临时拷贝，形参的改变p不影响实参str，而且这样的话，p指向的那段空间在p所在的代码块内都没有得到释放，出Getmory函数代码块后，局部变量p被销毁，这段动态申请的空间也就没有得到销毁，也无法再销毁。

另外，连锁反应，str还是指向空，strcpy函数执行的时候由于源空间不够容纳"hello world“

，就会出现第二个问题。

正确代码：

//正确代码:
void Getmory(char** p)
{
    *p = (char*)malloc(100);
}

void test(void)
{
    char* str = NULL;
    Getmory(&str);
    strcpy(str, "hello world");
    printf(str);
}

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

}

笔试题2：下面的代码能打印出"hello world“吗”-------->“返回栈空间地址问题”

//错误代码:
char* Getmory(void)
{
    char p[] = "hello world";
    return p;
}

void test()
{
    char* str = NULL;
    str = Getmory();
    printf(str);
}

int main()
{
    test();

    return 0;
}

答案：不能，Getmory函数中，"hello world”被放在了一个字符数组里，返回时返回的是数组名，也就是这个数组首元素的地址，Getmory函数结束时字符数组所占用的空间自动销毁，但是返回了栈空间的地址，一旦在test函数内对这地址解引用进行访问，那就是非法的，未知的，上述代码的错误原因和下述代码的错误类似。

//错误代码
int* test()
{
    int a = 10;
    return &a;
}

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

}

6 柔性数组

柔性数组：结构中的最后一个元素允许是未知大小的数组，这就和叫做【柔性数组】成员。

struct s
{
    int num;
    double e;
    int arr[0];
    //或int arr[0];
};

柔性数组的特点：

1. 结构体中柔性数组成员前必须包含至少一个其他非柔性数组成员。
2. 包含柔型数组的结构体的内存大小不包含柔型数组的内存大小。
3. 包含柔性数组的结构体在开辟内存时得使用malloc函数动态内存开辟，且开辟的空间大小必须大于结构体的大小，以适应柔型数组的预期大小。

struct s
{
    int num;
    int arr[0];
    //或int arr[0];
};

int main()
{
    printf("sizeof(struct s):>%d\n", sizeof(struct s));
    struct s* ps = (struct s*)malloc(sizeof(struct s) + 40);

    ps->num = 100;
    for (int i = 0; i < 10; i++)
    {
        ps->arr[i] = i;
    }

    for (int i = 0; i < 10; i++)
    {
        printf("%d\t", ps->arr[i]);
    }
    return 0;
}

struct s
{
    int num;
    int arr[0];
    //或int arr[0];
};

int main()
{
    printf("sizeof(struct s):>%d\n", sizeof(struct s));
    struct s* ps = (struct s*)malloc(sizeof(struct s) + 40);
    if (ps == NULL)
    {
        perror("malloc");
        exit(-1);
    }
    ps->num = 100;
    for (int i = 0; i < 10; i++)
    {
        ps->arr[i] = i;
    }

    for (int i = 0; i < 10; i++)
    {
        printf("%d\t", ps->arr[i]);
    }

    //柔性数组的柔性含义：可以realloc扩容
    struct s* temp = (struct s*)realloc(ps, sizeof(struct s) + 80);
    if (temp != NULL)
    {
        ps = temp;
    }

    for (int i = 0; i < 20; i++)
    {
        ps->arr[i] = i;
    }
    for (int i = 0; i < 20; i++)
    {
        printf("%d\t", ps->arr[i]);
    }
    free(ps);
    ps = NULL;
    return 0;
}