C语言动态内存分配详解

一、为什么需要动态内存分配？

在C语言中，我们常见的内存分配方式有：

int val = 20;           // 在栈空间上开辟4个字节
char arr[10] = {0};     // 在栈空间上开辟10个字节的连续空间

但这种方式有两个局限：

1. 空间大小在编译时就确定，无法动态调整。

2. 数组长度必须在声明时指定。

实际开发中，很多时候我们需要的空间大小只有在程序运行时才能确定，这时就需要动态内存分配。

---

二、动态内存分配相关函数

C语言提供了以下几个常用的动态内存分配函数（均在stdlib.h中声明，分配的空间都在堆区）：

1. malloc

void* malloc(size_t size);

• 申请一块size字节的连续空间，返回指向该空间的指针。

• 成功返回空间首地址，失败返回NULL。

• 返回类型为void*，需强制类型转换。

• size为0时，行为未定义。

示例：

int main()
{
    //向内存申请10个整型的空间
    int* p = (int*)malloc(10 * sizeof(int));
    if (p == NULL)
    {
        //打印开辟空间失败的原因
        printf("%s\n", strerror(errno));
    }
    else
    {
        //正常使用空间
        int i = 0;
        for (i = 0; i < 10; i++)
        {
            *(p + i) = i;
        }
        for (i = 0; i < 10; i++)
        {
            printf("%d ", *(p + i));
        }
    }
    //当动态申请的空间不再使用的时候
    //就应该还给操作系统
    //就比如说有个函数在申请内存，其他函数在不停的调用这个函数，这个函数申请了空间也不释放，那么就会占用操作系统很大一块空间，直至用完
    free(p);//此时空间虽然被释放了，但是p的值并没有发生变化，还是开辟空间的起始地址，造成的后果就是可能会利用这个p来找到并破坏这块空间
    p = NULL;//为了消除这个后果，将空指针赋值给p
	return 0;
}

2. free

void free(void* ptr);

• 释放由malloc/calloc/realloc动态分配的内存。

• 只能释放动态分配的空间，不能释放栈空间。

• ptr为NULL时，什么也不做。

3. calloc

void* calloc(size_t num, size_t size);

• 申请num个size字节的空间，并初始化为0。

• 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

示例：

int main()
{
    //malloc(10 * sizeof(int)     
    int* p = (int*)calloc(10, sizeof(int));//开辟10个整型大小的空间，并赋值为全0
    if (p == NULL)
    {
        //打印开辟空间失败的原因
        printf("%s\n", strerror(errno));
    }
    else
    {
        int i = 0;
        for (i = 0; i < 10; i++)
        {
            printf("%d ", *(p + i));
        }
    }
    //释放空间
    //free函数是用来释放动态开辟的空间
    free(p);
    p = NULL;
	return 0;
}

4. realloc

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

有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的申请内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整，原型如下：
       void* realloc (void*ptr, size_t size);
           ptr 是要调整的内存地址
           size 调整之后新大小
           返回值为调整之后的内存起始位置。
           这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。
realloc在调整内存空间的是存在两种情况：

           情况1：原有空间之后有足够大的空间
                  当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
           情况2：原有空间之后没有足够大的空间
                  当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。
           由于上述的两种情况，realloc函数的使用就要注意一些。

示例：

int main()
{
    int* p = (int*)malloc(20);
    if (p == NULL)
    {
        //打印开辟空间失败的原因
        printf("%s\n", strerror(errno));
    }
    else
    {
        int i = 0;
        for (i = 0; i < 5; i++)
        {
            *(p + i) = i;
        }
    }//只是在使用malloc开辟的20个字节的空间
    //假设这里20个字节的空间不能满足我们的需要
    //希望我们能够有40个字节的空间
    //这里可以使用realloc来调整动态开辟的内存


/*        这样写有风险
    realloc函数使用的注意事项
           情况1：原有空间之后有足够大的空间
                  当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化，返回旧的地址回去
                                      堆区的一条内存条
                   |                                                            |
                   |   malloc开辟的空间 |    realloc调整增加的空间   |          |
           情况2：原有空间之后没有足够大的空间
                  当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小
                  的连续空间来使用。这样函数返回的是一个新的内存地址。
                                      堆区的一条内存条
                   |                                                            |
                   |       使用掉的空间 |malloc开辟的空间 |    realloc调整增加的空间 |   //空间叠加起来大于内存条,
                                  重新找一块连续的空间增加内存，并把原来的数据拷贝过来,同时原有的malloc开辟的空间被释放掉，最后返回一个新的内存地址
                   |   malloc开辟的空间 |    realloc调整增加的空间 |            | 
           情况3：realloc函数空间调整失败，返回一个空指针，所以得用一个新的变量来接收realloc函数的返回值

           综上所述：得用一个新的变量来接收realloc函数的返回值，然后再赋值给p
 */
    int* ptr = realloc(p, 40);//这里的40单位是字节
    if (*ptr != NULL)
    {
        p = ptr;
        int i = 0;
        for (i = 5; i < 10; i++)
        {
            *(p + i) = i;
        }
        for (i = 0; i < 10; i++)
        {
            printf("%d ", *(p + i));
        }
    }
    //释放内存
    free(p);
    p = NULL;
	return 0;
}

---

三、常见动态内存分配错误

1. 对NULL指针解引用

   void test()
   {
       int* p = (int*)malloc(INT_MAX / 4);
       //*p = 20;//如果p的值是NULL，就会有问题,正确做法是进行空指针判断
       if (*p != NULL)
       {
           *p = 20;
       }
       free(p);
       p = NULL;
   }

2. 越界访问

   void test()
   {
       int i = 0;
       int* p = (int*)malloc(10 * sizeof(int));
       if (p == NULL)
       {
           //打印开辟空间失败的原因
           printf("%s\n", strerror(errno));
       }
       for (i = 0; i <= 10; i++)
       {
           *(p + i) = i;//当i是10的时候越界访问
       }
       free(p);
       p = NULL;
   }

3. 释放非动态内存

   void test()
   {
       int a = 10;
       int* p = &a;
       free(p);//ok?程序会死掉
   
   }

4. 释放动态内存的非起始地址

   void test()
   {
       int* p = (int*)malloc(100);
       p++;
       free(p);//p不再指向动态内存的起始位置，错误！
       p = NULL;
   }

5. 重复释放同一块内存

   void test()
   {
       int* p = (int*)malloc(100);
       free(p);
       free(p);//重复释放
   
       //防止重复释放
       free(p);
       p = NULL;//养成释放空间后，把指向开辟的空间的指针置为NULL的习惯
       free(p);
   }

6. 内存泄漏

   void test()
   {
       int* p = (int*)malloc(100);
       if (NULL != p)
       {
           *p = 20;
       }
   }
   int main()
   {
       test();
       while (1);//一直在开辟空间，但没有释放，占用大量内存
   }

---

四、经典面试题与易错点

1. 传递指针分配内存

错误写法：

void GetMemory(char* p)
{
    p = (char*)malloc(100);
}
void Test(void)
{
    char* str = NULL;
    GetMemory(str);                            
    strcpy(str, "hello world");
    printf(str);
}
int main()
{
    Test();
    /*
            1.程序崩溃：
                  p只是str的临时拷贝，p值的改变并不影响str，所以str一直是空指针，不是有效的地址，访问非法内存，
                  所以strcpy对空指针进行了解引用，程序会崩溃
            2.存在内存泄露的问题：
                  str以值传递的形式给p，p是GetMemory函数的形参，只是在函数内部有效，
                  等GetMemory函数返回之后，动态开辟的内存尚未释放，并且p被释放掉，开辟的空间就无法找到，导致内存浪费，一直被占用，
                  所以会造成内存泄露

    */
    return 0;
}

正确写法：

改正方法1
void GetMemory(char** p)
{
    *p = (char*)malloc(100);
}
void Test(void)
{
    char* str = NULL;
    GetMemory(&str);
    strcpy(str, "hello world");
    printf(str);
    free(str);
    str = NULL;
}
int main()
{
    Test();
    return 0;
}

改正方法2
char* GetMemory(char* p)
{
    p = (char*)malloc(100);
    return p;
}
void Test(void)
{
    char* str = NULL;
    str = GetMemory(str);
    strcpy(str, "hello world");
    printf(str);
    free(str);
    str = NULL;
}
int main()
{
    Test();
    return 0;
}

2. 返回栈空间地址

返回栈空间的地址问题
char* GetMemory(void)
{
    char p[] = "hello world";
    return p;
}
void Test(void)
{
    char* str = NULL;
    str = GetMemory();
    printf(str);
}
int main()
{
    Test();
    /*
           返回栈空间的地址问题
           程序崩溃
               str = GetMemory();  p的值确实是传给了str，但这行代码执行过后，GetMemory()函数的调用完成
               空间被释放，还给操作系统了，此时str所指向的地址的内容便不再确定，非法访问内存，打印结果未知。随机值
               所以程序崩溃。

    */
    return 0;
}

3. 忘记释放内存

void GetMemory(char** p, int num)
{
    *p = (char*)malloc(num);
}
void Test(void)
{
    char* str = NULL;
    GetMemory(&str, 100);
    strcpy(str, "hello");
    printf(str);
    //改进
    //free(str);//忘记释放动态开辟的内存空间，可能会造成内存泄露的风险
    //str = NULL;
}
int main()
{
    Test();
    return 0;
}

4. 释放后继续使用指针

void Test(void)
{
    char* str = (char*)malloc(100);
    strcpy(str, "hello");
    free(str);//free释放str所指向的空间后，并不会吧str置为空
    if (str != NULL)
    {
        strcpy(str, "world");
        /*
              free(str);str所指向的空间被释放掉了，不再属于str，此时 strcpy(str, "world");虽然可以把world拷贝过去，
              但是属于是非法访问内存，因为这块空间已经不属于你了，strcpy(str, "world")拷贝的话可能会修改正在使用这块空间的代码的数据，
              造成很严重的后果；
        */
        printf(str);
    }
}
int main()
{
    Test();
    return 0;
}

---

五、柔性数组（Flexible Array Member）

C99标准允许结构体的最后一个成员为不定长数组，称为柔性数组。

特点：

• 柔性数组成员前必须有至少一个其他成员。

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

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

示例：

 struct S
{
    int n;
    int arr[];//未知大小--柔性数组成员--数组的大小是可以调整的
};
 //柔性数组的使用   
 //代码1
 int main()
 {
     //struct S s;
     //printf("%d\n", sizeof(s));//输出的是4--计算柔性数组结构体的大小时，不包含柔性数组的大小
     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;
     }
     //调整空间
     struct S* ptr = realloc(ps, 44);//对柔性数组新增5个空间，总共10个空间
     if (ptr != NULL)
     {
         ps = ptr;
     }
     for (i = 5; i < 10; i++)
     {
         ps->arr[i] = i;
     }
     printf("%d \n", ps->n);
     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* ps = malloc(sizeof(struct S));
    ps->arr = malloc(5 * sizeof(int));
     int i = 0;
     for (i = 0; i < 5; i++)
     {
         ps->arr[i] = i;
     }
     for (i = 0; i < 5; i++)
     {
         printf("%d ", ps->arr[i]);

     }
     //调整空间
     int* ptr = realloc(ps->arr, 40);//对arr所指向的空间新增5个空间，总共10个空间
     if (ptr != NULL)
     {
         ps->arr = ptr;
     }
     for (i = 5; i < 10; i++)
     {
         ps->arr[i] = i;
     }
     for (i = 0; i < 10; i++)
     {
         printf("%d ", ps->arr[i]);

     }
 //释放空间
     free(ps->arr);
     ps->arr = NULL;
     free(ps);
     ps = NULL;
	return 0;
}

方法1的优势：

上述代码1和代码2可以完成同样的功能，但是方法1的实现有两个好处：

• 方便内存释放

     如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。 所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

•  这样有利于访问速度

     连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了， 反正你跑不了要用做偏移量的加法来寻址）

---

六、总结

• 动态内存分配是C语言灵活管理内存的关键。

• 正确使用malloc/calloc/realloc/free，避免常见错误。

• 柔性数组是结构体内存管理的高级技巧。

动态内存分配虽强大，但也需谨慎，养成良好的内存管理习惯，才能写出高质量的C语言代码。