C程序的内存开辟

静态存储区分配：静态存储区分配的内存是在编译时就确定的，生命周期随程序的运行始终存在。例如，全局变量和static变量就是在静态存储区分配内存的例子。
栈空间分配：栈空间分配是函数调用时自动进行的，函数内的局部变量和临时变量都是在栈上分配内存的。当函数调用结束时，栈上的内存会自动释放。
堆空间分配：堆空间分配是动态内存分配的一种方式，需要手动申请和释放内存。使用动态内存分配函数如malloc()、calloc()、realloc()来在堆上分配内存，使用free()函数来释放堆上的内存。堆上分配的内存在整个程序执行过程中都可用，并且需要手动释放，否则可能导致内存泄漏。
这也是本章要讲的主要内容

这些不同的内存分配方式适用于不同的场景，静态存储区适用于全局变量和长时间存在的变量，栈空间分配适用于函数的局部变量和临时变量，而堆空间分配适用于需要在程序运行过程中动态分配和释放内存的情况。

为什么存在动态内存分配

C语言存在动态内存分配的主要原因是为了灵活管理内存资源，并提供对内存的动态调整和使用。

相比静态内存分配(全局变量和局部静态变量）在编译时就确定所占内存的大小，无法根据程序的运行进行动态扩展和缩小。而动态内存分配可以根据程序运行的需求而进行动态申请和释放内存。

并且动态内存分配可以避免静态内存分配造成的过度浪费。例如一个数组：int arr[100];但我只想用一个整型大小，那么相对应的就浪费了99个整型大小的空间；

动态内存分配函数

动态内存分配函数都声明在

#include<stdlib.h>

malloc和free

这是C语言中最为常用的动态内存分配函数，且malloc()和free()经常搭配使用；

void* malloc (size_t size);

分配内存块

返回指向块开头的指针。

新分配的内存块的内容未初始化，保留不确定的值。

如果开辟成功，则返回一个指向开辟好空间的指针。

如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查.

由于malloc返回类型是void*，所以一般我们都会将它强转换对应的类型；

void free (void* ptr);

释放内存块

一般释放完的指针指向NULL;

下图是在空间开辟的大体思路：

下面看代码：

#include <stdio.h>
#include <stdlib.h>
int main()
{
  //int arr[10];
    //开辟
  int* p = (int*)malloc(sizeof(int)*10);
  if (p == NULL)
  {
    perror("malloc");
    return 1;
  }
  //开辟成功，就相当于一个数组，但是没有初始化
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d\n", *(p + i));
  }
    //释放
  free(p);
  p = NULL;//置空
  return 0;
}

对于开辟的空间，里面的内容是随机的；

下面就介绍一个自带初始化的内存开辟函数。

calloc

void* calloc (size_t num, size_t size);

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

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

以上面例子变化：

#include <stdio.h>
#include <stdlib.h>
int main()
{
  //int arr[10];
    //开辟
  int* p = (int*)calloc(10,sizeof(int));
  if (p == NULL)
  {
    perror("malloc");
    return 1;
  }
  //开辟成功，就相当于一个数组，但是没有初始化
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d\n", *(p + i));
  }
    //释放
  free(p);
  p = NULL;//置空
  return 0;
}

但对于上面的两个函数来说，当我们在堆区开辟内存后，当我们想改变开辟空间的大小时就得重新free掉。当然free完指针也该指向NULL，所以重新开辟不一定在原来地址上；

下面就介绍一种不用free掉的。

realloc

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

ptr 是要调整的内存地址

size 调整之后新大小

返回值为调整之后的内存起始位置。

这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。

realloc在调整内存空间的是存在两种情况：

情况1：原有空间之后有足够大的空间

情况2：原有空间之后没有足够大的空间

int main()
{
  int* p = (int*)malloc(40);
  if (p == NULL)
  {
    perror("malloc");
    return 1;
  }
  //初始化为1~10
  int i = 0;
  for (i = 0; i < 10; i++) 
  {
    p[i] = i + 1;
  }
  //增加一些空间
  int* ptr = (int*)realloc(p, 8000);
  if (ptr != NULL)
  {
    p = ptr;
    ptr = NULL;
  }
  else
  {
    perror("realloc");
    return 1;
  }
  //打印数据
  for (i = 0; i < 20; i++)
  {
    printf("%d\n", p[i]);
  }
  //释放
  free(p);
  p = NULL;
  return 0;
}

常见的动态内存错误

对空指针的解引用操作

void test()
{
 int *p = (int *)malloc(INT_MAX/4);
 *p = 20;//如果p的值是NULL，就会有问题
 free( p);
}

对于开辟失败的空间，那么p指向的就为空，所以我们开辟空间要养成习惯，加入条件判断；

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

void test()
{
 int i = 0;
 int *p = (int *)malloc(10*sizeof(int));
 if(NULL == p)
 {
 exit(EXIT_FAILURE);
 }
 for(i=0; i<=10; i++)
 {
 *(p+i) = i;//当i是10的时候越界访问
 }
 free(p);
}

这个道理和在数组中越界访问是一样的，在开辟空间之外访问，程序就会报错；

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

void test()
{
 int a = 10;
 int *p = &a;
 free(p);
}

对于指针p来说，它指向的是变量a的地址，而变量a开辟的空间所属空间在栈区，而free作用在堆区，两者根本没有任何联系，所以禁止这种操作；

使用free释放一块动态开辟内存的一部分

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

这样操作，在堆区中开辟的空间还有剩余，程序就会报错；

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

void test()
{
 int *p = (int *)malloc(100);
 free(p);
 free(p);//重复释放
}

对于一块动态内存，释放完在堆区上就没有空间的开辟了，再一次释放就会程序报错。

动态开辟内存忘记释放

void test()
{
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
 *p = 20;
 }
}
int main()
{
 test();
 while(1);
}

没有进行free释放malloc的空间，会造成内存泄漏；

例题

1

void GetMemory(char *p)
{
 p = (char *)malloc(100);
}
void Test(void)
{
 char *str = NULL;
 GetMemory(str);
 strcpy(str, "hello world");
 printf(str);
}

当程序跑起来时，会报错；

这是因为str传参过去，指针p指向的地址会创建一个内存空间；对于str指针来说没有任何影响，仍然为空，strcpy对于目标指针为空，将会报错；而当该函数结束时，那么p创建的内存由于没有free掉，会造成内存泄漏。

2

#include <stdio.h>
#include <stdlib.h>
char *GetMemory(void)
{
 char p[] = "hello world";
 return p;
}
void Test(void)
{
 char *str = NULL;
 str = GetMemory();
 printf(str);
}
int main()
{
    Test();
    return 0;
}

程序可以执行，但没有显示或者显示结果为错误信息；

这是由于GetMemory函数返回的是一个空指针，函数结束的时候p就为空；

返回的就是一个空指针，打印出来的就是错误的；

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);
}
int main()
{
  Test();
  return 0;
}

打印结果：hello

相对于第一题来说，是地址传参，所以可以打印出来，但没有free掉p指向的空间，所以还会造成内存泄漏；

4

void Test(void)
{
 char *str = (char *) malloc(100);
 strcpy(str, "hello");
 free(str);
 if(str != NULL)
 {
 strcpy(str, "world");
 printf(str);
 }
}
int main()
{
    Test();
    return 0;
}

打印结果：

gcc环境：无

VS：world

在上面我们就说，对于释放完的空间，最好置空；当str指向的空间被释放，虽然str指向的地址不为空，但由于没有空间大小，在不同的编译环境下就会出错；

柔性数组

柔性数组（Flexible Array）是一种在编程语言中使用的数据结构，它允许在已知的固定部分后面添加可变长度的数据。

通常情况下，数组的大小是固定的，即在声明数组时需要指定数组的大小。然而，柔性数组在声明时只需要指定已知的固定部分的大小，而不需要指定可变部分的大小。

柔性数组的一种常见应用是在C语言中实现变长结构体。通过在结构体中定义一个数组成员作为柔性数组，可以根据需要动态改变结构体的大小，而不需要重新分配内存空间。

示例代码：

#include<stdio.h>
#include<stdlib.h>
struct flex_array {
    int length;
    int data[]; // 柔性数组
};
int main() 
{
    int size = 5;
    struct flex_array* my_array = malloc(sizeof(struct flex_array) + size * sizeof(int));
   if(my_array==NULL)
    {
        perror("my_array");
        return;
    }
    //柔性数组的动态内存分配形式
    my_array->length = size;
    for (int i = 0; i < size; i++) {
        my_array->data[i] = i + 1;
        printf("my_array->data[%d]:%d\n",i,my_array->data[i]);
    }
     free(my_array);
    my_array=NULL;
    return 0；
 }

好处：

第一个好处是：方便内存释放

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

第二个好处是：这样有利于访问速度.

连续的内存有益于提高访问速度，也有益于减少内存碎片。

C语言--动态内存管理(图解)