AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【进阶C语言】动态内存分配

2023-10-20 38
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 函数参数：根据用户的需求需要开辟多大的字节空间，为无符号的字节。返回值：malloc函数成功开辟内存后，会返回该内存的起始地址，可以根据需要强制转换成任意的类型；若开辟空间失败，则会返回空指针（NULL）。头文件：#include<stdlib.h>

一、malloc和free

1.malloc函数

（1）函数原型

image.png

函数参数：根据用户的需求需要开辟多大的字节空间，为无符号的字节。

返回值：malloc函数成功开辟内存后，会返回该内存的起始地址，可以根据需要强制转换成任意的类型；若开辟空间失败，则会返回空指针（NULL）。

头文件：#include<stdlib.h>


（2）使用方法


1）申请空间：

#include<stdio.h>
#include<stdlib.h>
int  main()
{
  int* p = (int*)malloc(40);
  return 0;
}

   目的：申请十个整形空间，所以参数传：4*10=40。

结果：用一个整形指针来接收其返回值

2）检查安全和使用

#include<stdio.h>
#include<stdlib.h>
int  main()
{
  int* p = (int*)malloc(40);
  if (p == NULL)//必须对指针安全性检查
  {
    printf("申请空间失败\n");
    return;
  }
  //申请成功就开始用
  int i = 0;
  for (i=0;i<10;i++)
  {
    *(p+i) = i;
  }
  i = 0;
  for (i=0;i<10;i++)
  {
    printf("%d\n",*(p+i));
  }
  return 0;
}

当使用结束之后，我们需要删除该动态生成的空间，则需要对空间进行释放，这就是我们接下来讲的free。

2.free函数

（1）函数原型

image.png

   1.参数为动态开辟内存的首地址

2.无参数返回

3.头文件#include<stdlib.h>

（2）配合动态内存开辟的函数使用

前面malloc函数开辟的内存还没释放，接下来它们配合使用。

#include<stdio.h>
#include<stdlib.h>
int  main()
{
  int* p = (int*)malloc(40);
  if (p == NULL)
  {
    printf("申请空间失败\n");
    return;
  }
  //申请成功就开始用
  int i = 0;
  for (i=0;i<10;i++)
  {
    *(p+i) = i;
  }
  i = 0;
  for (i=0;i<10;i++)
  {
    printf("%d\n",*(p+i));
  }
  free(p);
  p = NULL;//及时将指针置空
  return 0;
}

注意事项:

1.free只能释放由动态内存开辟的空间

2.free释放的是指针所指向的那块空间，释放后指针仍在，但是指向的空间不咋了，就会变成野指针，所以我们需要及时置空。

二、calloc

1.函数定义

image.png

函数参数：第一个参数是需要开辟的数据个数，第二个是该数据类型的内存大小。

返回值：calloc函数成功开辟内存后，会返回该内存的起始地址，可以根据需要强制转换成任意的类型；若开辟空间失败，则会返回空指针（NULL）。

头文件：#include<stdlib.h>


2.calloc的使用

目的：需要开辟10个整形空间

#include<stdio.h>
#include<stdlib.h>
int  main()
{
  int* p = (int*)calloc(10,sizeof(int));
  if (p == NULL)
  {
    printf("申请空间失败\n");
    return;
  }
  //申请成功就开始用
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    *(p + i) = i;
  }
  i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d\n", *(p + i));
  }
  free(p);
  p = NULL;//及时将指针置空
  return 0;
}

运行结果：

image.png

根据malloc和calloc函数使用的两段代码，好像除了名字和参数之外，其他没什么不同呀？其实他们还有一处区别。


3.calloc函数与malloc函数的区别

（1）区别


malloc函数开辟好空间之后，并不会对其初始化，但是calloc函数开辟好空间之后，会将数据的每一个字节都初始化成0。


（2）对照


1）malloc

image.png

2）calloc

image.png

除了以上三点不同之外，其他的都一样。所以我们需要根据内存需求，需不需要初始化内存而选择合适的开辟方式。

三、realloc

1.函数定义

realloc可以对已有的内存进行调整

image.png

函数参数：ptr是要调整的内存地址，size为内存调整之后的新大小，单位是内存总大小（字节）

返回值：内存调整后的起始地址，同样有申请内存成功和失败两种情况

头文件：#include<stdlib.h>


2.realloc申请空间成功的两种情况

（1）原空间后的空间足够大


开辟空间方式：直接原有内存之后直接追加空间，原来空间的数据不发生变化。

image.png

（2）原空间之后没有足够大的空间

    原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小

的连续空间来使用。这样函数返回的是一个新的内存地址。而原有数据也会被拷贝到新内存中。

3.realloc的使用

#include<stdio.h>
#include<stdlib.h>
int  main()
{
  int* p = (int*)calloc(10,sizeof(int));
  if (p == NULL)
  {
    printf("申请空间失败\n");
    return;
  }
  //申请成功就开始用
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    *(p + i) = i;
  }
  i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d\n", *(p + i));
  }
  //要求加大空间内存
  int* ptr = realloc(p,40*sizeof(int));
  if (ptr == NULL)
  {
    printf("内存开辟失败\n");
    return;
  }
  p = ptr;//将新开辟好的内存赋值原地址
  free(p);
  p = NULL;//及时将指针置空
  return 0;
}

realloc的使用一般在原有空间的情况下，同样也需要对指针进行判空操作和free。

我们也可以看到，free和这些函数是紧紧联系在一起的。

四、常见错误解析

这些错误都是动态内存开辟前后的问题，与指针也有很大的联系

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

错误写法：

int main()
{
  int* p = (int*)malloc(4);
  *p = 20;
  printf("%d\n",*p);
  return 0;
}

malloc有可能开辟动态内存失败，则会返回NULL，这个时候对NULL指针解引用操作就是非法的。

正确写法：

int main()
{
  int* p = (int*)malloc(4);
  *p = 20;
  if (p == NULL)//对指针安全性限制
  {
    perror(malloc);
    return;
  }
  printf("%d\n",*p);
//后续需要对内存释放
  return 0;
}

知识点1：在每次动态内存开辟完成之后，都要先对其指针进行判空操作；若非空，才能对其进行后续的操作。

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

错误写法：

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

错误的后果提示：

image.png

知识点2：在对指针解引用操作时，要注意指针所指向的个数

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

错误写法：

test()
{
  int a = 100;
  int* p = &a;
  free(p);//错误
}

知识点3：free函数只能释放动态开辟的内存，否则会非法。

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

错误写法：

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

   当p++之后，p指向的起始位置就变了，当free(p)之后，会释放不完整，也会造成内存泄漏。

知识点4：使用指针，尽量不要改变指针指向的起始地址。可以再重新使用新指针进行++或--操作；或者+1/-1操作。

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

错误写法：

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

知识点5：切记要对内存释放，但是每一块内存有且只能释放一次。

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

错误：

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

这是忘记对动态内存的释放的，也是不可取的。

五、关于动态内存开辟的笔试题

分析下面四道代码题存在什么问题

运行Test函数会有什么样的后果

1.对NULL解引用操作

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

   1.str指针为空

2.malloc开辟的空间只是被p指向，没有被str指向（相当于形参的改变不影响实参）

3.所以strcpy函数就会对NULL指针进行解引用操作

4.没有free操作，还会操作内存泄漏

图解：

image.png

正确写法：

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;
}

2.问题代码：

char *GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}

  1.字符数组p为栈空间的局部变量，函数返回后会被销毁

2.数组被销毁，返回的p就是野指针（所指向的空间已不属于自己）

类型代码情况：

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

这种运行的结果仍然可以得到10，虽然空间依然属于p，但是值仍在，没有被其他的数据覆盖。但是下面这种情况则不行。

image.png

3.题目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释放

4.问题代码：

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

1.str所指向的空间已被销毁


2.str变成野指针，对其解引用操作为非法


六、柔性数组

1.柔性数组的定义

标准定义：C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。


也就是说，柔性数组不是指简单的数组，而是在结构体中的数组。


有两种写法：


第一种：

typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;

a数组就称为柔性数组。但是这种定义方式容易报错，所以我们还有第二种。

第二种：

typedef struct st_type
{
int i;
int a[];//柔性数组成员
}type_a;

就是不需要指定数组的大小，数组的大小是未知的。


2.柔性数组的特点

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


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


因为柔性数组是不计入sizeof的计算的，只有柔性数组成员sizeof就会出错。


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


在计算包含柔性数组的结构体时，柔性数组是不计入内存的计算的。大于结构体内存大小的部分就会分配给柔性数组。


（4）代码验证

struct S
{
  int a;
  int arr[];
};
int main()
{
  struct S s;
  printf("%zd\n",sizeof(s));//计算该结构体的内存大小
  return 0;
}

运行的结果：

image.png

柔性数组确实是不会参加sizeof对结构体的计算

3.柔性数组的使用

（1）开辟空间

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct S
{
  int a;
  int arr[];
};
int main()
{
  struct S* ps=(struct S*)malloc(sizeof(struct S)+16);
  if (ps == NULL)
  {
    perror(malloc);
    return;
  }
  return 0;
}

image.png

（2）增容（realloc函数）

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct S
{
  int a;
  int arr[];
};
int main()
{
  struct S* ps=(struct S*)malloc(sizeof(struct S)+16);
  if (ps == NULL)
  {
    perror(malloc);
    return;
  }
  struct S* str = (struct S*)realloc(ps,sizeof(struct S)+40);
  if (str != NULL)
  {
    ps = str;
  }
  else
  {
    perror(realloc);
    return;
  }
  return 0;
}

image.png

用malloc开辟空间之后，再用reallo增容（减容）。增容之后的空间都会加在柔性数组上，这个时候数组的大小就可以根据realloc变化，因此称为柔性数组。

 

4.柔性数组的优势

（1）方便内存释放

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct S
{
  int a;
  int arr[];//定义一个柔性数组
};
int main()
{
  struct S* ps=(struct S*)malloc(sizeof(struct S)+16);
  if (ps == NULL)
  {
    perror(malloc);
    return;
  }
  struct S* str = (struct S*)realloc(ps,sizeof(struct S)+40);
  if (str != NULL)
  {
    ps = str;
  }
  else
  {
    perror(realloc);
    return;
  }
  free(ps);
  ps = NULL;
  return 0;
}

因为开辟的空间都是连续的，在一块内存中，所以只需要free一次即可。

我们再对比一下另一种写法就更加明显了。

结构体中有指针的写法：

struct S
{
  char c;
  int i;
  int* data;//定义一个指针
};
int main()
{
  struct S* ps = (struct S*)malloc(sizeof(struct S));
  if (ps == NULL)
  {
    perror("malloc1");
    return 1;
  }
  ps->c = 'w';
  ps->i = 100;
  ps->data = (int*)malloc(20);
  if (ps->data == NULL)
  {
    perror("malloc2");
    return 1;
  }
  int i = 0;
  for (i = 0; i < 5; i++)
  {
    ps->data[i] = i;
  }
  for (i = 0; i < 5; i++)
  {
    printf("%d ", ps->data[i]);
  }
  //空间不够了，增容
  int* ptr = (int*)realloc(ps->data, 40);
  if (ptr == NULL)
  {
    perror("realloc");
    return 1;
  }
  else
  {
    ps->data = ptr;
  }
  //增容成功就使用
  //...
  //释放
  free(ps->data);//第一次
  ps->data = NULL;
  free(ps);//第二次
  ps = NULL;
  return 0;
}

1.两次开辟空间的原因是使得他们的数据都开辟在堆区上

2.使得跟第一种一样的写法，突然第一种的优势

3.这种写法开辟的空间是不连续的，容易造成空间零碎空间，导致空间浪费。


（2）有利于访问速度和节约内存


连续的内存有益于提高访问速度，也有益于减少内存碎片，更大程度的利用内存空间。


文章标签：
C语言
安全
关键词：
C语言内存
C语言进阶
C语言动态内存分配
小小娥子
目录
相关文章
aliyun6365824167
|
2月前
|
存储 编译器 C语言
【C语言篇】数据在内存中的存储（超详细）
浮点数就采⽤下⾯的规则表⽰，即指数E的真实值加上127（或1023），再将有效数字M去掉整数部分的1。
aliyun6365824167
163 0
写代码的大学生
|
4月前
|
C语言
指针进阶（C语言终）
指针进阶（C语言终）
写代码的大学生
52 4
可能只会写BUG
|
1月前
|
存储 大数据 C语言
C语言 内存管理
本文详细介绍了内存管理和相关操作函数。首先讲解了进程与程序的区别及进程空间的概念，接着深入探讨了栈内存和堆内存的特点、大小及其管理方法。在堆内存部分，具体分析了 `malloc()`、`calloc()`、`realloc()` 和 `free()` 等函数的功能和用法。最后介绍了 `memcpy`、`memmove`、`memcmp`、`memchr` 和 `memset` 等内存操作函数，并提供了示例代码。通过这些内容，读者可以全面了解内存管理的基本原理和实践技巧。
可能只会写BUG
36 5
可能只会写BUG
|
1月前
|
缓存 Linux C语言
C语言 多进程编程(六)共享内存
本文介绍了Linux系统下的多进程通信机制——共享内存的使用方法。首先详细讲解了如何通过`shmget()`函数创建共享内存，并提供了示例代码。接着介绍了如何利用`shmctl()`函数删除共享内存。随后，文章解释了共享内存映射的概念及其实现方法，包括使用`shmat()`函数进行映射以及使用`shmdt()`函数解除映射，并给出了相应的示例代码。最后，展示了如何在共享内存中读写数据的具体操作流程。
可能只会写BUG
37 3
睡觉待开机
|
2月前
|
存储 程序员 C语言
【C语言】动态内存管理
【C语言】动态内存管理
睡觉待开机
41 6
chian-ocean
|
2月前
|
C语言
C语言动态内存管理
C语言动态内存管理
chian-ocean
31 4
cz游客
|
2月前
|
存储 NoSQL 程序员
C语言中的内存布局
C语言中的内存布局
cz游客
38 0
aliyun6365824167
|
2月前
|
C语言
【C语言篇】字符和字符串以及内存函数详细介绍与模拟实现（下篇）
perror函数打印完参数部分的字符串后，再打印⼀个冒号和⼀个空格，再打印错误信息。
aliyun6365824167
49 0
aliyun6365824167
|
2月前
|
存储 安全 编译器
【C语言篇】字符和字符串以及内存函数的详细介绍与模拟实现（上篇）
当然可以用scanf和printf输入输出，这里在之前【C语言篇】scanf和printf万字超详细介绍（基本加拓展用法）已经讲过了，这里就不再赘述，主要介绍只针对字符的函数.
aliyun6365824167
40 0
是基德吖
|
3月前
|
存储 缓存 C语言
【C语言】字符函数，字符串函数，内存函数
C语言中的字符串函数和内存函数
是基德吖
35 0
【C语言】字符函数，字符串函数，内存函数

热门文章

最新文章

  • 1
    C语言及程序设计初步例程-17 赋值运算符与赋值表达式
  • 2
    C语言学习第一课
  • 3
    C语言的编译过程
  • 4
    《C语言程序设计：问题与求解方法》——第0章“理想厨房”的工作原理
  • 5
    《C语言及程序设计》程序阅读——洗牌
  • 6
    C语言及程序设计提高例程-11 全局变量和局部变量
  • 7
    C语言及程序设计初步例程-32 输出小星星
  • 8
    21、C语言中输入输出格式控制（1）
  • 9
    在文本文档中查找数据的应用---C语言+dos
  • 10
    C语言字符串库函数的实现
  • 1
    【C 言专栏】C 语言与硬件交互的方法
    167
  • 2
    【C 言专栏】C 语言中的数据结构应用
    83
  • 3
    【C 言专栏】C 语言实现网络通信程序
    156
  • 4
    【C 言专栏】C 语言中的模块化编程思想
    128
  • 5
    【C 言专栏】运用 C 语言进行图形编程
    148
  • 6
    【C 言专栏】C 语言中的错误处理机制
    132
  • 7
    【C 言专栏】C 语言与数据库的连接与操作
    206
  • 8
    【C 言专栏】优化 C 语言程序性能的策略
    160
  • 9
    【C 言专栏】C 语言中的位运算技巧
    152
  • 10
    【C 言专栏】C 语言与操作系统的交互
    83

    • 相关课程

    更多
  • 你的第一门C语言课
  • C语言学习教程
  • Go语言核心编程 - 数据结构和算法
  • Go语言核心编程 - 基础语法、数组、切片、Map

    • 相关电子书

    更多
  • 内存取证与IaaS云平台恶意行 为的安全监控
  • 云服务器ECS内存增强型实例re6全新发布
  • 低代码开发师（初级）实战教程
    • 下一篇
    无影云桌面