动态内存管理

        动态内存管理是指在程序运行时动态地分配和释放内存空间。在C语言中，动态内存管理通常使用malloc、calloc、realloc和free等函数来完成。

        空间分配通常发生在堆中，通过malloc、calloc、realloc等函数动态分配内存空间。在程序执行过程中，堆的大小可以动态调整，以满足程序对内存空间的需求。

malloc：用于分配指定大小的内存块。它接受一个参数，即要分配的字节数，并返回一个指向已分配内存的指针。如果分配失败，返回NULL。

void *malloc(size_t size);

calloc：用于分配指定数量和大小的内存块，并将内存初始化为零。它接受两个参数，分别是要分配的元素数量和每个元素的大小，并返回一个指向已分配内存的指针。如果分配失败，返回NULL。

void *calloc(size_t num, size_t size);

realloc：用于更改之前分配的内存块的大小。它接受两个参数，分别是之前分配的内存块指针和新的大小，并返回一个指向重新分配内存的指针。如果分配失败，返回NULL。

如果realloc函数的第一个参数是NULL，则其行为类似于malloc。

realloc(NULL,60);//相当于malloc(60)

realloc 函数在重新分配内存时有两种可能的情况：

1. 内存块扩展：如果之前分配的内存块后面有足够的空闲内存空间，realloc 可以直接在原始内存块的末尾扩展内存，而不需要搬迁数据。这种情况下，realloc 可以快速完成内存的重新分配，因为没有需要复制的数据。

2. 内存块迁移：如果之前分配的内存块后面没有足够的空间以容纳扩展后的内存块，或者由于其他原因无法直接在原始内存块上扩展，则 realloc 需要在内存中寻找一个新的适当大小的内存块，将原始内存块的内容复制到这个新的内存块中，然后释放原始内存块，返回新内存块的地址。这种情况下，realloc 的操作会比较耗时，因为需要将数据从原始内存块复制到新的内存块中。

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

free：用于释放之前动态分配的内存块。它接受一个指向要释放的内存块的指针。

void free(void *ptr);

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

#include <stdio.h>
#include <stdlib.h>

int main()
{
    short* p1 = (short*)malloc(10 * sizeof(short));  // 分配10个short的内存块
    short* p2 = (short*)calloc(10, sizeof(short));   // 分配10个short的内存块，并初始化为0
    short* p3 = (short*)realloc(p2, 20 * sizeof(short));//重新分配p2的内存块大小为20个short的内存块

    // 释放动态分配的内存
    free(p1);
    free(p2);
    free(p3);

    return 0;
}

常见的动态内存错误：

1 对NULL指针的解引用操作

#include <stdio.h>

int main() {
    int *ptr = NULL;
    // 解引用空指针
    int value = *ptr; // 这里会导致未定义行为

    return 0;
}

2 对非动态开辟内存使用free释放

#include <stdio.h>
#include <stdlib.h>

int main() {
    int num = 10;
    int *ptr = &num; // 非动态分配内存

    free(ptr); // 错误：尝试释放非动态分配的内存

    return 0;
}

3 使用free释放时不是其开辟的动态内存首地址

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int* p = (int*)malloc(40);
    if (p == NULL)
    {
        return 1;
    }
    
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        *p = i;
       //p++; //这里会改变p的地址 导致释放空间的时候会出错
       //可以使用如下形式
        p[i] = i;//相当于 *(p+i)
        printf("%d ",p[i]);
    }
    
    free(p);//指向的地址必须是动态开辟空间的起始地址
    p = NULL;

    return 0;
}

4 对同一块动态内存多次释放

        对同一块动态分配的内存多次调用 free 函数会导致严重的问题，通常会引发内存错误或崩溃。这是因为在首次调用 free 后，操作系统会将这块内存标记为可用，再次调用 free 会尝试释放已经被释放的内存，破坏了内存管理结构。

当尝试释放已经释放的内存时，通常会发生以下情况：

Double Free Error（双重释放错误）：操作系统会检测到对已经释放的内存进行第二次释放，从而引发错误。
Heap Corruption（堆破坏）：释放已经释放的内存可能会导致堆结构被破坏，进而影响程序的其他部分，甚至导致程序崩溃。

#include <stdlib.h>

int main() {
    int *ptr = (int *)malloc(10 * sizeof(int));

    free(ptr); // 第一次释放内存

    // 尝试再次释放相同的内存块
    free(ptr); // 这里会导致问题

    return 0;
}

        要避免这种情况，确保每块动态分配的内存只被释放一次。要么跟踪哪些内存块已经被释放，要么使用一些技术，如将指针设置为 NULL 来避免重复释放。

int main() {
    int *ptr = (int *)malloc(10 * sizeof(int));

    if (ptr == NULL) 
    {
        return 1;
    }
        
    //其他操作...

     free(ptr);
     ptr = NULL; // 将指针设置为 NULL 来避免重复释放

    // 很多其他操作...

    free(ptr);//就算忘记了再次释放时 因为上面把ptr置为空指针所以 free函数不做任何操作。

    return 0;
}

5 动态开辟内存忘记释放（内存泄漏）

        内存泄漏是指在动态内存分配过程中，由于程序员未正确释放先前分配的内存，导致该内存无法被再次使用。内存泄漏可能会导致程序运行时占用的内存越来越多，最终导致程序性能下降或崩溃。

#include <stdlib.h>

int main() {
    int *ptr = (int *)malloc(10 * sizeof(int));

    // 没有调用 free(ptr) 来释放内存  

    return 0;
}

一个典型的错误：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void GetMemory(char *p)
{
    // 函数接收一个char类型指针作为参数
    // 在这个函数中，传入的指针p被重新赋值为一个新分配的内存块的指针
    p = (char *)malloc(100); // 分配了100字节的内存空间 出了这个函数 p被销毁了 申请的空间没被释放 造成内存泄漏。
    
}

void Test(void)
{
    // 声明一个指针str，并初始化为NULL
    char *str = NULL;
    // 调用GetMemory函数，传入str指针的拷贝
    // 在函数内部将str的拷贝重新分配了内存，但原始指针str仍然指向NULL
    GetMemory(str);
    // 尝试将字符串"hello world"拷贝到NULL指针所指向的内存地址，将导致未定义行为
    strcpy(str, "hello world");
    // 尝试打印NULL指针所指向的字符串，也将导致未定义行为
    printf(str);
}

int main()
{
    // 调用Test函数 程序崩溃
    Test();
}

改正：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void GetMemory(char** p)
{
    // 函数接收一个指向char类型指针的指针作为参数
    // 在函数中为指针p所指向的指针分配内存空间
    *p = (char*)malloc(100); // 分配了100字节的内存空间

    if (*p == NULL)
    {
        // 检查内存分配是否成功
        printf("Memory allocation failed.\n");
        return;
    }
}

void Test(void)
{
    // 声明一个指针str，并初始化为NULL
    char* str = NULL;
    // 调用GetMemory函数，传入str指针的地址
    GetMemory(&str);
    // 现在str指针指向了一个分配的内存块，可以安全地进行操作
    strcpy(str, "hello world");
    printf(str); // 打印字符串
    // 记得在不需要使用内存块的时候释放它并置为空指针
    free(str);
    str = NULL;
}

int main()
{
    // 调用Test函数
    Test();

    return 0;
}

柔性数组：

柔性数组（Flexible Array）是结构体最后一个元素且是一个未知大小的数组，这种数组称为柔性数组。通过柔性数组，可以实现动态大小的数据结构，而无需动态分配内存。

柔性数组的特点：

结构体中的柔性数组成员前面必须至少有一个其他成员。

sizeof 返回的这种结构大小不包括柔性数组的内存。

#include <stdio.h>

struct S
{
    int n;//4
    int arr[];//柔性数组成员
};

int main()
{
    
    printf("%d\n", sizeof(struct S));//4

    return 0;
}

包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

#include <stdio.h>
#include <stdlib.h> // 需要包含stdlib.h头文件

struct S
{
    int n;         // 4
    int arr[];     // 柔性数组成员
};

int main()
{
    struct S s; // 4 这里没给柔性数组分配空间
    printf("%d\n", sizeof(s)); // 4

    struct S* ps = (struct S*)malloc(sizeof(struct S) + 96); // 柔性数组的使用

    if (ps == NULL) {
        fprintf(stderr, "动态内存分配失败\n");
        return 1;
    }

    ps->n = 100;
    int i = 0;

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

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

    struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 80);
    if (ptr != NULL)
    {
        ps = ptr;
        ptr = NULL;
    }

    // 释放动态分配的内存
    free(ps);
    ps = NULL;

    return 0;
}