【C语言航路】第十三站:动态内存管理(下)

简介: 【C语言航路】第十三站:动态内存管理

3.对非动态开辟的空间使用free

如下代码所示,a是栈区上的数据,但是我们对a进行了free,那么最终的结果就是程序挂了

#include<stdlib.h>
int main()
{
  int a = 0;
  int* p = &a;
  free(p);
  p = NULL;
  return 0;
}

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

如下代码所示,我们在赋值的过程中p移动了,最终free的p指向的是动态开辟内存的一部分,那么此时程序就会挂了

#include<stdio.h>
#include<stdlib.h>
int main()
{
  int* p = (int*)malloc(100);
  if (p == NULL)
  {
    perror("malloc");
    return 1;
  }
  int i = 0;
  for (i = 0; i < 20; i++)
  {
    *p = i + 1;
    p++;
  }
  free(p);
  p = NULL;
  return 0;
}

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

如下图所示,对p进行了两次释放,那么最终结果就是程序挂了

#include<stdio.h>
#include<stdlib.h>
int main()
{
  int* p = (int*)malloc(100);
  if (p == NULL)
  {
    perror("malloc");
    return 1;
  }
  free(p);
  free(p);
  return 0;
}

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

如下代码所示,有两处错误

第一处错误是没有释放malloc出来的空间

第二处错误是我们后续无法找到malloc出来的空间了,无法后续进行释放

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

四、一些经典的题目

题1

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
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();
  return 0;
}

这段代码最终的结果是程序挂了

这段代码有两处地方错误

第一处是str应该传传二级指针。因为我们是需要改变的str里面的值的。所以要传str的地址过去,而我们没有传str的地址过去。这就导致了str还是一个NULL,因此我们使用strcpy的时候,将hello world放到空指针处肯定会导致程序挂了

第二处是我们的开辟的空间指向给了p这个指针,但是p是一个局部变量,随着函数的结束,p的值也就找不到了。也就是说我们这里以后也找不到动态开辟的空间了。这就导致了内存泄漏

当然在这个代码中我们还需要注意的是printf(str)这种写法。

我们平时打印的都是printf("hehe\n")这种形式的,这两种写法都一样的,printf接受hehe传的也是首元素的地址。所以我们直接传一个str这个首元素地址也是可以的。

题2

#include<stdio.h>
#include<stdlib.h>
#include<string.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加上static修饰一下。这样这个数组就在静态区了。不会被销毁了。

我们也可以将这个数组变成一个指针来接收,因为字符串常量本来就在只读数据区,我们的指针只是接收这个地址的。所以也是可以的

类似的例子还有下面这个

#include<stdio.h>
int* test()
{
  int a = 10;
  return &a;
}
int main()
{
  int* p = test();
  printf("%d", *p);
}

这个也是返回了栈空间的地址。所以理论上说他应该也是随机值,但是我们运行后会发现,结果是10。这其实是一种偶然。因为我们创建好test的栈帧以后,在test的栈帧里面创建了a的栈帧。然后我们返回a的地址的时候,我们还没有破坏修改a的栈帧。所以数据还在,所以我们打印出来的还是10

但是我们一旦破坏了这个栈帧。结果就改变了

题3

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
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;
}

这段代码从运行结果上来看,是没有什么问题的。

这段代码出现的问题是存在内存泄漏,我们动态开辟了空间,但是没有free掉

题4

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
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;
}

这段代码从运行结果上来说,可以输出world。但是还是存在一定的问题的

因为我们动态开辟了一个空间,但是我们拷贝完hello之后就将他释放掉了,这块空间已经不归str管理了,但是str还有这块空间的地址,我们还判断了str不为空时,进行拷贝world,这个判断肯定是为真的,但是此时已经造成了非法访问了。

修改方式应该是free之后,将str置为NULL

五、C/C++程序的内存开辟

1. 栈区(stack):在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

2. 堆区(heap):一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。分配方式类似于链表。

3. 数据段(静态区)(static)存放全局变量、静态数据。程序结束后由系统释放。

4. 代码段:存放函数体(类成员函数和全局函数)的二进制代码。

这样我们也就理解了之前所说的static修饰局部变量会使生命周期变长的原因了

实际上普通的局部变量是在栈区分配空间的,栈区的特点是在上面创建的变量出了作用域就销毁。

但是被static修饰的变量存放在数据段(静态区),数据段的特点是在上面创建的变量,直到程序结束才销毁

所以生命周期变长

六、柔性数组

1.柔性数组的概念以及声明

C99 中,结构中的最后一个元素允许是未知大小的数组,这就叫做『柔性数组』成员

如下代码所示,柔性数组的声明有两种方式,一种是数组后面直接加[ ] ,另外一种是数组后面的[]里面的数据写为0

struct S1
{
  int i;
  char c;
  int a[];
};
struct S2
{
  int i;
  char c;
  int a[0];
};

2.柔性数组的特点

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

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

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

对于1、2两个特点

在下面这段代码中,我们定义了一个结构体,我们计算这个结构体的大小最终结果是4

可见只包含了n的大小,这也说明了有柔性数组成员的前面必须至少有一个其他成员。

#include<stdio.h>
struct S
{
  int n;
  char arr[];
};
int main()
{
  printf("%d\n", sizeof(struct S));
}

对于特点3

下面这段代码就是为这个结构体开辟一块空间

#include<stdio.h>
#include<stdlib.h>
struct S
{
  int n;
  char arr[];
};
int main()
{
  struct S* ps = (struct S*)malloc(sizeof(struct S) + sizeof(char) * 10);
}

他的内存是这样的

3.柔性数组的使用

如下代码所示,我们创建了一个柔性数组,并且给他开辟了空间

当我们想要更多的空间时候,使用realloc增容

最后释放这块空间就可以了

#include<stdio.h>
#include<stdlib.h>
struct S
{
  int n;
  char arr[];
};
int main()
{
  struct S* ps = (struct S*)malloc(sizeof(struct S) + sizeof(char) * 10);
  if (ps == NULL)
  {
    perror("malloc");
  }
  ps->n = 100;
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    ps->arr[i] = 'W';
  }
  struct S* p = (struct S*)realloc(ps, sizeof(struct S) + sizeof(char) * 20);
  if (p == NULL)
  {
    perror("realloc");
    return 1;
  }
  ps = p;
  p = NULL;
  for (i = 10; i < 20; i++)
  {
    ps->arr[i] = 'Q';
  }
  for (i = 0; i < 20; i++)
  {
    printf("%c ", ps->arr[i]);
  }
  free(ps);
  ps = NULL;
  return 0;
}

4.柔性数组的优点

我们了解了柔性数组的使用以后,我们可能也知道这样的使用也跟柔性数组差不多

#include<stdio.h>
#include<stdlib.h>
struct S
{
  int n;
  char* arr;
};
int main()
{
  struct S* ps = (struct S*)malloc(sizeof(struct S));
  if (ps == NULL)
  {
    perror("ps malloc");
    return 1;
  }
  ps->n = 10;
  ps->arr = (char*)malloc(sizeof(char) * 10);
  if (ps->arr == NULL)
  {
    perror("ps->arr malloc");
    return 1;
  }
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    ps->arr[i] = 'Q';
  }
  for (i = 0; i < 10; i++)
  {
    printf("%c ", ps->arr[i]);
  }
  printf("\n");
  char* ptr = (char*)realloc(ps->arr, sizeof(char) * 20);
  if (ptr == NULL)
  {
    perror("realloc");
    return 1;
  }
  ps->arr = ptr;
  ptr = NULL;
  for (i = 10; i < 20; i++)
  {
    ps->arr[i] = 'W';
  }
  for (i = 10; i < 20; i++)
  {
    printf("%c ", ps->arr[i]);
  }
  free(ps->arr);
  ps->arr = NULL;
  free(ps);
  ps = NULL;
  return 0;
}

但是呢他相比较柔性数组还是有一定的缺点的

柔性数组:

一次malloc、一次free、内存连续

上面这个代码的方式

两次malloc、两次free、内存不连续

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

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

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

连续的内存有益于提高访问速度,也有益于减少内存碎片。但是其实也没有提高多高了,因为后续还是需要使用偏移量的加法寻址


总结

本小节,讲解了动态内存管理,malloc、calloc、realloc、free函数的使用、柔性数组、C/C++的内存开辟、以及常见的动态内存管理错误

如果对你有帮助的话,不要忘记点赞加收藏哦!!!

想获得更多优质内容,不要忘记关注我哦!!!

相关文章
|
3月前
|
C语言 C++
C语言 之 内存函数
C语言 之 内存函数
47 3
|
1月前
|
存储 编译器 程序员
【C语言】内存布局大揭秘 ! -《堆、栈和你从未听说过的内存角落》
在C语言中,内存布局是程序运行时非常重要的概念。内存布局直接影响程序的性能、稳定性和安全性。理解C程序的内存布局,有助于编写更高效和可靠的代码。本文将详细介绍C程序的内存布局,包括代码段、数据段、堆、栈等部分,并提供相关的示例和应用。
56 5
【C语言】内存布局大揭秘 ! -《堆、栈和你从未听说过的内存角落》
|
1月前
|
存储 缓存 算法
【C语言】内存管理函数详细讲解
在C语言编程中,内存管理是至关重要的。动态内存分配函数允许程序在运行时请求和释放内存,这对于处理不确定大小的数据结构至关重要。以下是C语言内存管理函数的详细讲解,包括每个函数的功能、标准格式、示例代码、代码解释及其输出。
72 6
|
2月前
|
传感器 人工智能 物联网
C 语言在计算机科学中尤其在硬件交互方面占据重要地位。本文探讨了 C 语言与硬件交互的主要方法,包括直接访问硬件寄存器、中断处理、I/O 端口操作、内存映射 I/O 和设备驱动程序开发
C 语言在计算机科学中尤其在硬件交互方面占据重要地位。本文探讨了 C 语言与硬件交互的主要方法,包括直接访问硬件寄存器、中断处理、I/O 端口操作、内存映射 I/O 和设备驱动程序开发,以及面临的挑战和未来趋势,旨在帮助读者深入了解并掌握这些关键技术。
70 6
|
2月前
|
存储 C语言
C语言如何使用结构体和指针来操作动态分配的内存
在C语言中,通过定义结构体并使用指向该结构体的指针,可以对动态分配的内存进行操作。首先利用 `malloc` 或 `calloc` 分配内存,然后通过指针访问和修改结构体成员,最后用 `free` 释放内存,实现资源的有效管理。
212 13
|
2月前
|
存储 编译器 数据处理
C 语言结构体与位域:高效数据组织与内存优化
C语言中的结构体与位域是实现高效数据组织和内存优化的重要工具。结构体允许将不同类型的数据组合成一个整体,而位域则进一步允许对结构体成员的位进行精细控制,以节省内存空间。两者结合使用,可在嵌入式系统等资源受限环境中发挥巨大作用。
83 11
|
2月前
|
大数据 C语言
C 语言动态内存分配 —— 灵活掌控内存资源
C语言动态内存分配使程序在运行时灵活管理内存资源,通过malloc、calloc、realloc和free等函数实现内存的申请与释放,提高内存使用效率,适应不同应用场景需求。
|
2月前
|
存储 C语言 开发者
C 语言指针与内存管理
C语言中的指针与内存管理是编程的核心概念。指针用于存储变量的内存地址,实现数据的间接访问和操作;内存管理涉及动态分配(如malloc、free函数)和释放内存,确保程序高效运行并避免内存泄漏。掌握这两者对于编写高质量的C语言程序至关重要。
76 11
|
2月前
|
存储 算法 程序员
C 语言指针详解 —— 内存操控的魔法棒
《C 语言指针详解》深入浅出地讲解了指针的概念、使用方法及其在内存操作中的重要作用,被誉为程序员手中的“内存操控魔法棒”。本书适合C语言初学者及希望深化理解指针机制的开发者阅读。
|
2月前
|
并行计算 算法 测试技术
C语言因高效灵活被广泛应用于软件开发。本文探讨了优化C语言程序性能的策略,涵盖算法优化、代码结构优化、内存管理优化、编译器优化、数据结构优化、并行计算优化及性能测试与分析七个方面
C语言因高效灵活被广泛应用于软件开发。本文探讨了优化C语言程序性能的策略,涵盖算法优化、代码结构优化、内存管理优化、编译器优化、数据结构优化、并行计算优化及性能测试与分析七个方面,旨在通过综合策略提升程序性能,满足实际需求。
79 1

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等