C语言动态内存管理函数(malloc、free、calloc、realloc)

简介: 开辟内存空间的⽅式有两个缺点:• 空间开辟⼤⼩固定• 数组声明时,必须指定数组的⻓度,长度⼀旦确定了便不能调整而实际情况是,很多时候我们所需要的空间⼤⼩只有在程序运⾏后才能知道,为此C语⾔引⼊了动态内存开辟这个概念,让程序员⾃⼰可以申请和释放内存空间,这样就显得比较灵活了。

为什么要有动态内存分配

我们已经掌握的内存开辟⽅式有:

int val = 20 ;          // 在栈空间上开辟四个字节的连续空间
char arr[ 10 ] = { 0 }; // 在栈空间上开辟十 个字节的连续空间

但是上述开辟内存空间的⽅式有两个缺点:

• 空间开辟⼤⼩固定

• 数组声明时,必须指定数组的⻓度,长度⼀旦确定了便不能调整

而实际情况是,很多时候我们所需要的空间⼤⼩只有在程序运⾏后才能知道,为此C语⾔引⼊了动态内存开辟这个概念,让程序员⾃⼰可以申请和释放内存空间,这样就显得比较灵活了。

malloc函数

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

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

包含头文件:<stdlib.h>

注意事项:

1、返回的是无类型指针void*,在使用时一定要强制转换为所需要的类型

2、使用完开辟的内存空间后一定要释放空间,如果不释放会造成内存泄漏

3、如果开辟成功,则返回一个指向开辟好空间的指针

4、如果开辟失败,则返回一个NULL指针

5、size的值为0时,它将分配一个大小为0的内存块,并返回一个指向该内存块的指针。但是需要注意的是,这个指针可能是无效的,因为在分配大小为0的内存块时,并不会真正地分配任何内存空间,所以最终情况还是要看编译器的反应

6、动态内存分配相关的函数,它们要操作或者申请的的内存空间属于内存中的堆区


#include <stdio.h>
#include <stdlib.h>
int main()
{
  //申请10个整型(40个字节)的空间 
  int* p = (int*)malloc(10 * sizeof(int));
    //判断内存空间是否非开辟成功
  if (p == NULL)
  {
    perror("malloc");    如果开辟失败就是用perror函数返回错误信息
    return 1;
  }
  //使用空间
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    *(p + i) = i;
  }
  for (i = 0; i < 10; i++)
  {
    printf("%d ", p[i]);
  }
  return 0;
}

free函数

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

作用:对申请的动态内存空间进行释放

包含头文件:<stdlib.h>

注意事项:

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

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

3、free仅释放了空间里数据,但空间的地址仍未释放,需要将指向开辟空间地址的指针置为空

#include <stdio.h>
#include <stdlib.h>
int main()
{
  //申请10个整型(40个字节)的空间 
  int* p = (int*)malloc(10 * sizeof(int));
  if (p == NULL)
  {
    perror("malloc");
    return 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所指向的动态内存
  p = NULL;   
  return 0;
}


calloc函数

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

作用:为num个大小为size的元素开辟一块空间,并把空间的每个字节初始化为0

包含头文件:<stdlib.h>

注意事项:

1、与malloc函数的区别只在于calloc会在返回地址前,将申请的空间中的每个字节都初始化为0

#include <stdio.h>
#include <stdlib.h>
int main()
{
  //申请10个整型(40个字节)的空间 
  int* p = (int*)calloc(10,sizeof(int));
  if (p == NULL)
  {
    perror("calloc");
    return 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所指向的动态内存
  p = NULL;//free只是释放了空间是空间的地址仍未释放
  return 0;
}

realloc函数

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

作用:使动态内存管理更加灵活,对申请的动态内存大小进行调整

包含头文件:<stdlib.h>

注意事项:

1、返回调整后的内存起始地址,ptr指向要调整的内存空间,size为调整后的大小

2、内存空间调整后,原内存中的数据移动到新空间,并释放原空间

3、ralloc在调整内存空间时存在两种情况:原有空间够和空间不够

①原有空间足够(返回地址为旧地址)



②原有空间不够(返回地址为新地址,但原来指向该地址的指针仍然存在)


#include <stdio.h>
#include <stdlib.h>
int main()
{
  //malloc申请五个字节的内存空间
  int* p = (int*)malloc(5 * sizeof(int));
  if (p == NULL)
  {
    perror("malloc");
    return 1;
  }
  int i = 0;
  for(i = 0; i < 5; i++)
  {
    *(p + i) = i + 1;
  }
  for (i = 0; i < 5; i++)
  {
    printf("%d ", *(p + i));
  }
  int* ptr = (int*)realloc(p, 400);
  if (ptr != NULL)   //扩容成功
  {
    p = ptr;   //还是要使用原来的p就把新地址赋值给p
    ptr = NULL;  //此时ptr为空指针所以将ptr设置为空
  }
  else  //扩容失败报错
  {
    perror("realloc");
    return 1;
  }
  free(p);
  p = NULL;
  return 0;
}


关于“int* ptr = (int*)realloc(p, 400);”“p = ptr;”解释:


进行扩容时,ptr是指向新空间的指针,如果扩容成功的同时我们还想继续使用原来的p指针只需要将ptr所指向的地址赋值给p(虽然被扩容了原来空间不存在了但是p指针指向的地址仍然保留),此时ptr变成空指针了所以要将NULL赋值给ptr,但是注意在赋值结束后不能对ptr进行free操作否则新申请的内存空间就会被释放且ptr和p都会变成野指针

tips:当realloc函数的第一个参数是NULL指针的时候,功能类似于malloc函数
int*p = (int*)realloc(NULL,40);       //malloc(40)

常见的动态内存的错误

对空指针的解引用操作

#include <stdio.h>
int main()
{
  int* p = (int*)malloc(40);
  if (p == NULL)
  {
    return 1;
  }
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    *(p + i) = i;
  }
  return 0;
}

如果不添加对p指针的判断,当malloc函数开辟空间失败返回空指针p的时候,下面对于p+i的解引用就变成了对空指针的解引用,但是空指针只能被取地址但是不能被解引用所以出错

tips:

return 0  代表程序正常退出

return 1  代表程序异常退出

free掉部分动态开辟的内存


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


动态开辟内存未释放(内存泄漏)

#include <stdio.h>
void test()
{
  int* p = (int*)malloc(40);
  if (p == NULL)
  {
    return;
  }
  //......
  if (5 == 3 + 2)
  {
    return;
  }
  free(p);
  p = NULL;
}
int main()
{
  test();
  return 0;
}

程序运行结束后free(p)的操作没有起作用,或者说test函数结束时开辟的内存空间仍未被释放,这是因为在if(5 == 3+2)的操作时函数直接返回了并未进行free操作,这种未释放开辟的内存空间的问题就叫内存泄漏

动态内存经典笔试题:

#include <stdio.h>
#include <string.h>
void GetMemory(char* p)
 {
   p = (char*)malloc(100);
 }
 void Test()
 {
   char* str = NULL;
   GetMemory(str);
   strcpy(str, "hello world");
   printf(str);   //语法正确
 }
 int main()
 {
   Test();
   return 0;
 }


这个程序的问题在于,str原本是一个空指针,现在将str的值传递给了GetMemory中的指针p该过程属于传值调用(形参是实参的拷贝对形参的操作不会影响实参),然后malloc函数开辟内存空间,当GetMemory函数结束后p指针被释放但开辟的内存空间不会被释放,同时也没有一个指针指向该空间,最后str依然是一个空指针,所以无法将hello world拷贝给str指向的内存空间



#include <stdio.h>
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;
 }
 int main()
 {
   Test();
   return 0;
 }


有关传值调用和传址调用中的指针的值和指针的地址的补充:

指针的值:即指针变量的值,指针str的值为NULL,所以传址调用传递给p的就是NULL。

指针的地址:即对指针&后得到的值,形参是二级指针


我们将实参设置为str的地址、形参设置为char** p,此时p为二级指针它指向一级指针str所在的地址,接着我们对p解引用得到的就是一级指针str所在的地址,就可以实现对str指向空间的修改。

柔性数组

柔性数组是为了配合动态内存管理的使用,满足以下三条要求的数组我们称之为柔性数组:

1、必须位于结构体中

2、必须为最后一个成员(前面必须要有成员)

3、数组的大小必须未知

柔性数组的特点:

1、sizeof返回的结构体大小不包括柔性数组的大小

2、包含柔性数组成员的结构体⽤malloc 函数进⾏内存的动态分配,并且分配的内存应该⼤于结构体的⼤⼩,以适应柔性数组的预期⼤⼩

柔性数组的使用

#include <stdio.h>
struct st_type
{
  int i;
  int a[];  //柔性数组
};
int main()
{
  //使用malloc开辟44个字节的空间 = 结构体成员大小 + 想要的柔性数组大小
  struct st_type* p = (struct st_type*)malloc(sizeof(struct st_type) + 10 * sizeof(int));
  if (p == NULL)
  {
    perror("malloc");
    return 1;
  }
  //使用过程
  int i = 0;
  p->i = 100;                        
  for (i = 0; i < 10; i++)
  {
    p->a[i] = i;
  }
  //希望结构中的a数组长度变为60个字节
  struct st_type* ptr = (struct st_type*)realloc(p,sizeof(struct st_type) + 15 * sizeof(int));
  if (ptr != NULL)
  {
    p = ptr;
    ptr = NULL;
  }
  else
  {
    perror("realloc");
    return 1;
  }
  return 0;
}

同样的我们可以使用以下代码实现和柔性数组一样的功能:

#include <stdio.h>
struct st_type
{
  int i;
  int* a;  //柔性数组
  //在VS中int a[0]的形式也可以,但是不同编译器可能只能用其中一种
};
int main()
{
  //使用malloc开辟一个大小为空间结构体大小的空间
  struct st_type* p = (struct st_type*)malloc(sizeof(struct st_type));
    //对开辟失败的判断
  if (p == NULL)
  {
    perror("malloc");
    return 1;
  }
    //为结构体成员i赋值
  p->i = 100;
    //使用malloc为柔性数组开辟一个40字节大小的空间
  p->a = malloc(10*sizeiof(int));
    if(p->a == NULL)
    {
        perror("malloc");
    return 1;
    }                  
    //给a指向的空间进行初始化,因为a指向的是一片空间所以可以视为数组         
  for (i = 0; i < 10; i++)
  {
    p->a[i] = i;
  }
  //后面我们又希望a指向的空间为15个整型
  int* ptr = (int*)realloc(p->a,15 * sizeof(int));
  if (ptr == NULL)
  {
     perror("realloc");
     return 1;
  }
  else
  {
    p->a = ptr;
    ptr = NULL;
  }
    //使用过程
    free(p->a);
    p->a = NULL;
    free(p)
    p = NULL;
  return 0;
}


对于前后两者之间的对比:

前者(使用一次malloc):⽅便内存释放

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

后者(使用多次malloc):这样有利于访问速度

连续的内存空间有益于提⾼访问速度,也有益于减少内存碎⽚,但其实没提高多少......


内存碎片

malloc申请内存空间时分配的内存空间是随机的,图中空白区域就是分配后剩余的内存碎片:


 C/C++中程序内存区域划分

简单了解



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


堆区(heap): ⼀般由程序员进行内存空间的分配和释放,若程序员不释放,程序结束时可能由操作系统自己回收,分配⽅式类似于链表

数据段/静态区(static):存放全局变量、静态数据,程序结束后由系统自动释放

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

相关文章
|
9天前
|
程序员 C语言
C语言库函数 — 内存函数(含模拟实现内存函数)
C语言库函数 — 内存函数(含模拟实现内存函数)
20 0
|
20天前
|
编译器 C语言 C++
【C语言】memset()函数(内存块初始化函数)
【C语言】memset()函数(内存块初始化函数)
24 0
|
20天前
|
编译器 C语言 C++
【C语言】memcpy()函数(内存块拷贝函数)
【C语言】memcpy()函数(内存块拷贝函数)
38 0
|
20天前
|
编译器 C语言 C++
【C语言】calloc()函数详解(动态内存开辟函数)
【C语言】calloc()函数详解(动态内存开辟函数)
24 0
|
20天前
|
存储 前端开发 编译器
【C语言】memmove()函数(拷贝重叠内存块函数详解)
【C语言】memmove()函数(拷贝重叠内存块函数详解)
32 1
|
23天前
|
安全 程序员 C++
【C++ 基本知识】现代C++内存管理:探究std::make_系列函数的力量
【C++ 基本知识】现代C++内存管理:探究std::make_系列函数的力量
97 0
|
30天前
|
存储 安全 程序员
C语言内存管理
C语言内存管理
14 0
|
1月前
|
存储 程序员 Shell
【C/C++ 内存管理函数】C语言动态内存管理大揭秘:malloc、calloc、realloc与new的对比与差异
【C/C++ 内存管理函数】C语言动态内存管理大揭秘:malloc、calloc、realloc与new的对比与差异
172 0
|
21天前
|
C语言 C++
【C语言】rand()函数(如何生成指定范围随机数)
【C语言】rand()函数(如何生成指定范围随机数)
16 0