C语言之动态内存管理篇(1)下

简介: C语言之动态内存管理篇(1)2

关于就是realloc函数返回的指针的两种不同的情况。

【情况1 】


要扩展内存就直接原有内存之后直接追加空间,原来空间的数据不发生变化。

  • realloc函数此时的返回值是旧的空间的起始地址


【情况2】


原有空间之后没有足够多的空间时,扩展的方法是:在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。 且realloc函数有三个特点

  • realloc函数会将旧的空间的数据,拷贝到新的空间里
  • realloc函数拷贝完成后,会将旧的空间释放掉
  • realloc函数此刻的返回值不是原来的地址,而是新的空间的起始地址


关于原地和异地扩容的验证:

【原地扩容】

#include<stdio.h>
#include<stdlib.h>
int main()
{
  int* p1 = (int*)malloc(40);
  int* p2 = (int*)realloc(p1,80);//扩容40
  printf("p1=%p\n", p1);
  printf("p2=%p", p2);
  return 0;
}

【异地扩容】

#include<stdio.h>
#include<stdlib.h>
int main()
{
  int* p1 = (int*)malloc(40);
  int* p2 = (int*)realloc(p1,800);//扩容760
  printf("p1=%p\n", p1);
  printf("p2=%p", p2);
  return 0;
}


当然除此之外,realloc还可以当成malloc来使用,只要传空指针即可。

所以所以 ptr可以为空指针NULL

#include<stdio.h>
#include<stdlib.h>
int main()
{
  int* ptr = (int*)realloc(NULL, 10 * sizeof(int));
  if (ptr == NULL)
  {
    perror("realloc");
    return 1;
  }
  free(ptr);
  ptr = NULL;
  return 0;
}

常见的动态内存错误

  • 对NULL指针的解引用操作
  • 对动态开辟空间的越界访问
  • 对非动态开辟内存使用free释放
  • 使用free释放一块动态开辟内存的一部分
  • 对同一块动态内存多次释放
  • 动态开辟内存忘记释放(内存泄漏)

接下来我们一个一个纠错!

NO1.  

//对NULL指针的解引用操作
void test()
{
  int* p = (int*)malloc(40);
  //不做返回值的判断,就可能是使用空指针解引用
  *p = 20;//如果p的值是NULL,就会有问题
  free(p);
}

【修改】加上返回值的判断


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

NO2.

//对动态开辟空间的越界访问
#include<stdio.h>
void test()
{
  int i = 0;
  int* p = (int*)malloc(10 * sizeof(int));
  if (NULL == p)
  {
    perror("malloc");
    return 1;
  }
  for (i = 0; i <= 10; i++)
  {
    *(p + i) = i;//当i是10的时候越界访问
  }
  free(p);
  p = NULL;
}
int main()
{
  test();
  return 0;
}

【修改】不越界即可


#include<stdio.h>
void test()
{
  int i = 0;
  int* p = (int*)malloc(10 * sizeof(int));
  if (NULL == p)
  {
    perror("malloc");
    return 1;
  }
  for (i = 0; i < 10; i++)
  {
    *(p + i) = i;//当i是10的时候越界访问
  }
  free(p);
  p = NULL;
}
int main()
{
  test();
  return 0;
}

NO3.

//对非动态开辟内存使用free释放
#include<stdio.h>
void test()
{
  int a = 10;
  int* p = &a;
  free(p);
  p = NULL;//err
}
int main()
{
  test();
  return 0;
}

【修改】不可以哈,删去free


//对非动态开辟内存使用free释放
#include<stdio.h>
void test()
{
  int a = 10;
  int* p = &a;
}
int main()
{
  test();
  return 0;
}

NO4.

//使用free释放一块动态开辟内存的一部分
//示例1
#include<stdio.h>
void test()
{
  int* p = (int*)malloc(100);
  p++;
  free(p);//p不再指向动态内存的起始位置
}
int main()
{
  test();
  return 0;
}
//示例2
#include<stdio.h>
#include<stdlib.h>
int main()
{
  int* p = (int*)calloc(10, sizeof(int));
  if (p == NULL)
  {
    perror("calloc");
    return 1;
  }
  //赋值
  int i = 0;
  for (i = 0; i < 5; i++)
  {
    *p = i;
    p++;
  }
  //0 1 2 3 4 0 0 0 0 0
  for (i = 0; i < 5; i++)
  {
    printf("%d ", p[i]);
  }
  free(p);//只是释放了后面五个0
  p = NULL;
  return 0;
}

【修改】不要让p移动,想移动就另外设置一个指针让它去移动。养成好习惯不要动起始的指针


//示例1
#include<stdlib.h>
#include<stdio.h>
void test()
{
  int* p = (int*)malloc(100);
  int* ps = NULL;
  if (p == NULL)
  {
    perror("malloc");
    return 1;
  }
  else
  {
    ps = p;
  }
  ps++;
  free(p);
  p = NULL;//p不再指向动态内存的起始位置
}
int main()
{
  test();
  return 0;
}
//示例2
#include<stdio.h>
#include<stdlib.h>
int main()
{
  int* p = (int*)calloc(10, sizeof(int));
  if (p == NULL)
  {
    perror("calloc");
    return 1;
  }
  //赋值
  int i = 0;
  for (i = 0; i < 5; i++)
  {
    p[i] = i;
  }
  //0 1 2 3 4 0 0 0 0 0
  for (i = 0; i < 5; i++)
  {
    printf("%d ", p[i]);
  }
  free(p);//只是释放了后面五个0
  p = NULL;
  return 0;
}

NO5.

//对同一块动态内存多次释放
#include<stdlib.h>
#include<stdio.h>
void test()
{
  int* p = (int*)malloc(100);
  free(p);
  free(p);//重复释放
}
int main()
{
  test();
  return 0;
}

【修改】不要多次释放


#include<stdlib.h>
#include<stdio.h>
void test()
{
  int* p = (int*)malloc(100);
  free(p);
}
int main()
{
  test();
  return 0;
}
#include<stdlib.h>
#include<stdio.h>
void test()
{
  int* p = (int*)malloc(100);
  free(p);
  p = NULL;
  free(p);//ok
}
int main()
{
  test();
  return 0;
}

NO6.

//动态开辟内存忘记释放(内存泄露)
//示例1
#include<stdlib.h>
#include<stdio.h>
void test()
{
  int* p = (int*)malloc(100);
  if (NULL != p)
  {
    *p = 20;
  }
}
int main()
{
  test();
  while (1);//忘记释放
}
//示例2
#include<stdlib.h>
#include<stdio.h>
void test()
{
  int* p = (int*)malloc(100);
  if (NULL != p)//这里直接跳出循环
  {
    *p = 20;
  }
  free(p);//无用
  p = NULL;
}
int main()
{
  test();//调用完成 malloc申请的空间还在
  //没有忘记释放。但是释放没有用
  while (1);//死循环程序退出不了
}

【修改】 忘记释放或在函数内部释放了但是没有使用都会造成内存泄露


#include<stdlib.h>
#include<stdio.h>
int* test()
{
  int* p = (int*)malloc(100);
  if (NULL != p)
  {
    *p = 20;
  }
  return p;
}
int main()
{
  int *p=test();
  free(p);
  p = NULL;
  while (1);//忘记释放
}

动态开辟的空间一定要正确释放!!

✔✔✔✔✔最后,感谢大家的阅读,若有错误和不足,欢迎指正!下篇博文我们讲解几道相关笔试题

代码------→【gitee:唐棣棣 (TSQXG) - Gitee.com

联系------→【邮箱:2784139418@qq.com】

目录
相关文章
|
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 和设备驱动程序开发,以及面临的挑战和未来趋势,旨在帮助读者深入了解并掌握这些关键技术。
69 6
|
2月前
|
存储 C语言
C语言如何使用结构体和指针来操作动态分配的内存
在C语言中,通过定义结构体并使用指向该结构体的指针,可以对动态分配的内存进行操作。首先利用 `malloc` 或 `calloc` 分配内存,然后通过指针访问和修改结构体成员,最后用 `free` 释放内存,实现资源的有效管理。
212 13
|
2月前
|
存储 编译器 数据处理
C 语言结构体与位域:高效数据组织与内存优化
C语言中的结构体与位域是实现高效数据组织和内存优化的重要工具。结构体允许将不同类型的数据组合成一个整体,而位域则进一步允许对结构体成员的位进行精细控制,以节省内存空间。两者结合使用,可在嵌入式系统等资源受限环境中发挥巨大作用。
82 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

热门文章

最新文章