保姆级教学 - C语言 之 动态内存管理

简介: 保姆级教学 - C语言 之 动态内存管理

为什么会有动态内存的分配


看下面代码:

①创建一个整型叫a并初始化赋值为10

②创建一个10个元素的数组,并全部初始化为0

int main()
{
  int a = 10;         //在栈区空间开辟了四个字节
  int arr[10] = { 0 };//在栈区空间连续开辟了10*4=40个字节
 
  return 0;
}

于是我们发现上述开辟空间有两个特点

①开辟空间大小是固定的;

②数组开辟空间是连续有长度的,且确定了空间大小不能改


malloc 和 free


malloc和free函数都需要包含头文件:include<stdlib.h>

动态内存开辟的函数:malloc函数

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

作用:malloc函数向内存申请一块连续可用的空间,并返回指向这块空间的指针

注:返回值为void*,malloc函数开辟空间的类型由使用者自己决定

动态内存的释放和回收:free函数

函数原型:void* free(*ptr)

作用:free函数释放动态开辟的内存

注:

①如果ptr指向的空间不是开辟动态内存的,则free函数的行为是未定义的

②如果ptr是NULL指针则函数什么事都不做

#include<stdlib.h>
int main()
{
  //int* p = (int*)malloc(10 * sizeof(int));
 
  if (p == NULL)
  {
    perror("malloc");
    return 1;//如果是空指针,返回1,下面代码不再执行
  }
  //使用
  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 = NULL;//为了避免p成为野指针,最后要把p设置为空指针
 
  return 0;
}


calloc 和 realloc


动态内存分配:calloc函数

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

calloc和malloc函数的区别是:calloc函数可以把开辟的每一个值初始化为0

calloc和malloc函数的共同点是:能调整空间


让动态内存管理更加灵活:realloc函数

函数原型:void*(void* ptr,size_t size);

其中ptr是要调整内存地址,size是调整之后的新大小

作用:对动态开辟内存大小做灵活的调整

int main()
{
  int* p = (int*)calloc(10, sizeof(int));
 
  if (p == NULL)
  {
    perror("malloc");
    return 1;//如果是空指针,返回1,下面代码不再执行
  }
  //使用
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d ", *(p + i));//打印出来10个都是0,说明calloc函数是初始化值为0
  }
 
  int* ptr = (int*)realloc(p, 12);
  if (ptr == NULL)
  {
    perror("realloc");//realloc调整空间失败返回NULL
    return 1;
  }
  else
  {
    p = ptr;
  }
  //释放空间
  free(p);
  p = NULL;//为了避免p成为野指针,最后要把p设置为空指针
 
  return 0;
}

relloc调整空间成功的两种情况


常见动态内存的错误


1)对NULL指针的解引用操作

错误示范

正确使用

int main()
{
  int* p = (int*)malloc(10 * sizeof(int));
 
  //对p判断是否为空指针
  if (p == NULL)
  {
    perror("malloc");
    return 1;//如果是空指针,返回1,下面代码不再执行
  }
 
  //使用
  *p = 20;
 
  //释放空间
  free(p);
  p = NULL;//为了避免p成为野指针,最后要把p设置为空指针
 
  return 0;
}

2)对内存开辟空间的越界访问

错误示范

正确使用

开辟内存空间多少,使用的时候就要对应多少

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

错误示范

p取非动态内存,然后p在非动态内存使用free释放

正确使用

free函数原型:void* free(*ptr)

作用:free函数释放动态开辟的内存

如果ptr指向的空间不是开辟动态内存的,则free函数的行为是未定义的

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

错误示范

p 不再指向动态内存的起始位置

正确使用

free函数释放时p要指向动态内存的起始位置

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

错误示范

正确使用

开辟动态内存使用完后一定要释放,并把p设置为空指针

6)动态开辟内存忘记释放(内存泄漏)

错误示范

正确使用

忘记释放不再使⽤的动态开辟的空间会造成内存泄漏


柔性数组


柔性数组的介绍

概念:在C99中,结构中的最后一个元素允许是未知大小的数组,这就叫【柔性数组】成员

我们先来看一段代码

struct st
{
  int i;
  int arr[0];//柔性数组成员
};
 
int main()
{
  printf("%zd\n", sizeof(struct st));
  return 0;
}

这段代码输出什么?

答案:4

为什么?

涉及到柔性数组的特点

1)sizeof返回的结构大小不包括柔性数组的内存

2)结构中的柔性数组成员前面必须至少一个成员

以上两点都很好的解释上面👆的代码

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

让我们接着讨论第三个特点

让我们想想,为什么要用柔性数组?


我们来看👇下面代码,代码有点长,每一段代码我注释了,供大家食用

代码①段

#include<stdlib.h>
//结构体
struct st
{
  char ch;
  int i;
  int arr[0];
};
 
int main()
{
  //printf("%zd\n", sizeof(struct st));//8
  //结构体指针+malloc函数开辟空间
  struct st* p = (struct st*)malloc(sizeof(struct st) + 10 * sizeof(int));
                                  //               8  + 10 * 4 = 48
  //判断p是否为空指针
  if (p == NULL)
  {
    perror("malloc");
    return 1;
  }
 
  //给结构体的成员赋值
  p->i = 66;
  p->ch = 'b';
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    p->arr[i] = i;
  }
 
  //数组空间不够,realloc函数使用
  struct st* ptr = realloc(p, sizeof(struct st) + 15 * sizeof(int));
  if (ptr == NULL)
  {
    perror("realloc");
    return 1;
  }
  else
  {
    p = ptr;
  }
 
  //继续使用
  for (i = 10; i < 15; i++)
  {
    ptr->arr[i] = i;
  }
 
  //打印输出
  for (i = 0; i < 15; i++)
  {
    printf("%d ", ptr->arr[i]);
  }
  printf("\n");
  printf("%d\n%c\n", ptr->i, ptr->ch);
  
  //释放空间
  free(ptr);
  ptr = NULL;
 
  return 0;
}

控制台结果显示

🆗,我们接着讨论为什么叫柔性数组?

代码②段

//结构体
struct st
{
  char ch;
  int i;
  int *arr;
};
 
int main()
{
  //printf("%zd\n", sizeof(struct st));//12
  //结构体指针+malloc函数开辟空间
  struct st* p = (struct st*)malloc(sizeof(struct st));
                                  
  //判断p是否为空指针
  if (p == NULL)
  {
    perror("malloc");
    return 1;
  }
 
  //给结构体的成员赋值
  p->i = 66;
  p->ch = 'b';
  p->arr = (int*)malloc(10 * sizeof(int));
 
  if (p->arr == NULL)
  {
    perror("malloc.2");
    return 1;
  }
 
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    p->arr[i] = i;
  }
 
  //数组空间不够,realloc函数使用
  int* ptr = (int*)realloc(p->arr, 15 * sizeof(int));
  if (ptr == NULL)
  {
    perror("realloc");
    return 1;
  }
  else
  {
    p->arr = ptr;
  }
 
  //继续使用
  for (i = 10; i < 15; i++)
  {
    p->arr[i] = i;
  }
 
  //打印输出
  for (i = 0; i < 15; i++)
  {
    printf("%d ", p->arr[i]);
  }
  printf("\n");
  printf("%d\n%c\n", p->i, p->ch);
 
 
  //释放空间
  free(p->arr);
  p->arr = NULL;
 
  free(p);
  p = NULL;
 
  return 0;
}

两段代码的区别

①段代码的两个优点

①方便内存释放

②利于访问速度

目录
相关文章
|
1月前
|
C语言 C++
C语言 之 内存函数
C语言 之 内存函数
33 3
|
20天前
|
C语言
【c语言】动态内存管理
本文介绍了C语言中的动态内存管理,包括其必要性及相关的四个函数:`malloc`、``calloc``、`realloc`和`free`。`malloc`用于申请内存,`calloc`申请并初始化内存,`realloc`调整内存大小,`free`释放内存。文章还列举了常见的动态内存管理错误,如空指针解引用、越界访问、错误释放等,并提供了示例代码帮助理解。
31 3
|
1月前
|
编译器 程序员 C语言
深入C语言:动态内存管理魔法
深入C语言:动态内存管理魔法
|
1月前
|
C语言 C++
保姆式教学C语言——数组
保姆式教学C语言——数组
17 0
保姆式教学C语言——数组
|
1月前
|
存储 程序员 编译器
C语言——动态内存管理与内存操作函数
C语言——动态内存管理与内存操作函数
|
1月前
|
程序员 C语言
C语言内存函数精讲
C语言内存函数精讲
|
22天前
|
存储 C语言
【c语言】字符串函数和内存函数
本文介绍了C语言中常用的字符串函数和内存函数,包括`strlen`、`strcpy`、`strcat`、`strcmp`、`strstr`、`strncpy`、`strncat`、`strncmp`、`strtok`、`memcpy`、`memmove`和`memset`等函数的使用方法及模拟实现。文章详细讲解了每个函数的功能、参数、返回值,并提供了具体的代码示例,帮助读者更好地理解和掌握这些函数的应用。
19 0
|
1月前
|
存储 C语言
深入C语言内存:数据在内存中的存储
深入C语言内存:数据在内存中的存储
|
1月前
|
C语言 C++
c语言回顾-内存操作函数
c语言回顾-内存操作函数
39 0
|
1月前
|
存储 C语言 C++
来不及哀悼了,接下来上场的是C语言内存函数memcpy,memmove,memset,memcmp
本文详细介绍了C语言中的四个内存操作函数:memcpy用于无重叠复制,memmove处理重叠内存,memset用于填充特定值,memcmp用于内存区域比较。通过实例展示了它们的用法和注意事项。
64 0