【C语言】动态内存管理

最新推荐文章于 2024-09-04 22:17:46 发布

是白玉鲸鸭

最新推荐文章于 2024-09-04 22:17:46 发布

阅读量762

点赞数 2

分类专栏： c语言文章标签： c语言算法 c++

本文链接：https://blog.csdn.net/purexiti/article/details/127579718

版权

c语言专栏收录该内容

11 篇文章 2 订阅

订阅专栏

一.为什么存在动态内存分配

//局部变量
int a = 2;//在栈区开辟4个字节
char arr[10] = {0};//在栈区开辟10个字节的连续的空间

上述的空间开辟方式有两个特点：

开辟空间大小是固定的
数组在声明的时候必须指定数组的长度，其所需要的内存在编译时分配

不过对于空间的开辟，有时我们需要想随便开辟多大空间的时候，就需要用到动态内存分配

二.动态内存函数的介绍

头文件均为 <stdlib.h>

malloc（开辟动态内存空间）

开辟空间成功时，返回指向函数分配的内存块的指针。
开辟空间失败时，则返回一个空指针(NULL)。因此malloc函数的返回值一定要做检查
返回值的类型是void* ,具体情况下进行强制类型转换
malloc函数和free函数应一块使用

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
  //想内存申请10个整形的空间
  int* p = (int*) malloc(40);//void*强制类型转换为int*
  if(p == NULL)//开辟失败 
  {
    printf("%s\n",strerror(errno));//打印错误原因
  }
  else//开辟成功 
  {
    int i = 0;
    for(i = 0; i<10;i++)
    {
      *(p + i) = i;
      printf("%d\n",*(p + i));
    }
  }
  return 0;
}

free（释放动态内存空间）

参数(ptr)为 指向以前使用或分配的内存块的指针
使用时，得有free函数应一块使用
如果参数 ptr 指向的空间不是动态开辟的，则free函数的行为是未定义的
如果参数ptr为NULL指针，则free函数什么都不会做

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
  //想内存申请10个整形的空间
  int* p = (int*) malloc(10*sizeof(int));//void*强制类型转换为int*
  //或int* p = (int*)calloc(40);
  if(p == NULL)//开辟失败 
  {
    printf("%s\n",strerror(errno));//打印错误原因
  }
  else//开辟成功 
  {
    int i = 0;
    for(i = 0; i<10;i++)
    {
      *(p + i) = i;
      printf("%d\n",*(p + i));
    }
  }
  
  free(p);
  p = NULL;
  return 0;
}

注意：

//当动态申请的空间不再使用的时候，就应该还给操作系统

//虽然程序结束后由于生命周期而自动会还给操作系统，但当我们后续还有，这回导致这白白浪费

//虽然free(p)释放了p的空间后，但p仍能找到这个空间，这是具有潜在危险的，所以我们可以直接将其置空

calloc(开辟动态内存空间)

返回值是指向开辟的空间的指针
开辟空间失败时，则返回一个空指针(NULL)
calloc与malloc参数用法不同；calloc会把空间的每个字节初始化为0,而malloc不会初始化
使用时，得有free函数应一块使用

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
  //想内存申请10个整形的空间
  int* p = (int*)calloc(10,sizeof(int));//void*强制类型转换为int*
  //或int* p = (int*)calloc(10,4);
  if(p == NULL)//开辟失败 
  {
    printf("%s\n",strerror(errno));//打印错误原因
  }
  else//开辟成功 
  {
    int i = 0;
    for(i = 0; i<10;i++)
    {
      printf("%d\n",*(p + i));
    }
  }
  
  free(p);
  p = NULL;
  return 0;
}
//0 0 0 0 0 0 0 0 0 0

realloc（调整动态内存的大小）

realloc函数能让动态内存管理更加灵活，在发现过去申请的内存空间过小或过大，可以使用realloc函数进行大小的调整

如果p指向的空间后有足够的内存空间可以追加，则直接追加，返回p
如果p指向的空间后没有足够的内存空间可以追加，则realloc函数会重找一个能满足需求的内存空间，并将原来内存中的数据拷贝过来，谁放掉旧的空间，最后返回新的内存空间
realloc函数调整失败后会返回一个空指针，不能拿p直接接收realloc，得用一个新的变量来接收返回值
使用时，得有free函数应一块使用

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
  //想内存申请10个整形的空间
  int* p = (int*)malloc(20);
  if(p == NULL)//开辟失败 
  {
    printf("%s\n",strerror(errno));//打印错误原因
  }
  else//开辟成功 
  {
    int i = 0;
    for(i = 0; i<5;i++)
    {
      *(p + i) = i;
      printf("%d ",*(p + i));
    }
  }

  int* p2 = (int*)realloc(p,40);
  int i = 0;
  for(i = 5;i < 10;i++);
  {
    printf("%d ",*(p2 + i));
  }
  //free(p);
  //p = NULL;

  return 0;
}

注意：

//当realloc第一个参数为NULL时，可以相当于malloc
int* p = (int*)realloc(NULL, 40);

三.常见的动态内存错误

对空指针的解引用操作

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
  int* p = (int*) malloc(40);
  
  //未对失败的情况下判定
  //万一malloc失败了，p被赋值为NULL
  //而下面的操作，都成了非法操作
  
  int i = 0;
  for(i = 0; i<10;i++)
  {
      *(p + i) = i;
  }
  
  free(p);
  p = NULL;
  
  return 0;
}

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

开辟动态内存空间后，后面进行操作时却超出这个空间的大小

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
  int* p = (int*) malloc(40);//void*强制类型转换为int*
  if(p == NULL)//开辟失败 
  {
    printf("%s\n",strerror(errno));//打印错误原因
  }
  else//开辟成功 
  {
    int i = 0;
    for(i = 0; i<20;i++)//  进行越界访问了
    {
      *(p + i) = i;
    }
  }
  return 0;
}

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

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
  int a = 10;//a在栈区
  int *p = &a;
  *p = 20;
  free(p);//free作用在堆区，强行乱指会造成程序崩溃
  
  return 0;
}

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

由于使p的地址发生改变时，释放的不再是原来的初始地址

#include <stdio.h>
#include <stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
  int* p = (int*)malloc(10*sizeof(int));
  if(p == NULL)//开辟失败 
  {
    printf("%s\n",strerror(errno));//打印错误原因
  }
  
  int i = 0;
  for (i = 0; i < 5; i++)
  {
    *p++ = i; 
  }
  free(p);
  p = NULL;

  return 0;
}

对一块动态内存进行多次释放

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
  int* p = (int*) malloc(40);//void*强制类型转换为int*
  if(p == NULL)//开辟失败 
  {
    printf("%s\n",strerror(errno));//打印错误原因
  }
  else//开辟成功 
  {
    int i = 0;
    for(i = 0; i<10;i++)//  进行越界访问了
    {
      *(p + i) = i;
    }
  }
  
  free(p);
  
  free(p);
  p = NULL;

  return 0;
}

可以在一个free后紧跟着将其置空，后面再出现时不会有影响

  free(p);
  p = NULL;
  free(p);

动态开辟内存忘记释放（内存泄露）

#include <stdio.h>
#include <stdlib.h>
void test()
{
  int* p = (int*)malloc(100);
  if(p != NULL)
  {
    *p = 20;
  }
}
int main()
{  
  test();
  while(1);

}

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

————动态开辟的空间一定要进行正确的释放

注意：

动态开辟的空间有2种回收方式：主动free ，程序结束

四.柔性数组

1.定义

在 C99 中，结构体中的最后一个元素允许是未知大小的数组，即柔性数组

struct a{
  int b;
  int arr[];//大小是未知的
};

//或

struct a{
  int b;
  int arr[0];//大小是未知的
};

2.特点

结构体中的柔性数组成员的前面必须至少有一个其它成员
sizeof 计算这种结构体的大小不包含柔性数组成员的
包含柔性数组成员的结构体用 malloc 函数进行内存分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小

#include<stdio.h>
#include<stdlib.h>
struct A{
  int b;
  int arr[];//大小是未知的
};
int main()
{
  //期待arr的大小是10个整形
  //结构体的初始化
  struct A* ps = (struct A*)malloc(sizeof(struct A ) + 10*sizeof(int));//前4个字节是给b的，后40个字节是给arr的
  //由于后面的是通过malloc开辟的动态内存，大小是可以调整的
  printf("%d",sizeof(ps));
  free(ps);
  ps = NULL;
  return 0;
}

//4