动态内存管理

简介: 动态内存管理

动态内存管理介绍

在以往开辟空间的方式有俩个特点:

1.空间开辟的大小是固定的

2.数组在声明的时候,必须指定数组的长度,数组所需要的内存在编译时已经被分配

int str[10] = {0};
  int i = 10;
  int arr[] = {1,2,3,4,5};

但是对于空间的需求,有时候我们所需要的空间大小在程序运行时才可得知,此时需要进行内存分配

  • 动态内存管理的函数放在堆区

动态内存函数

malloc

  • malloc函数介绍:

void* malloc ( size_t size);

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

  • 头文件:#include<stdlib.h>
  • 参数:内存块的大小(以字节为单位)
  • 返回值:如果成功返回被函数分配的内存块的指针,失败返回一个空指针,此指针的类型为void*,可以将其强制转换为所需要的数据指针类型,以便取消引用

注意事项:

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

2.如果开辟失败,返回一个NULL指针,因此malloc的返回值一定要做检查

3.返回值的类型时void*,所以malloc函数并不知道开辟空间的类型,具体在使用的时候使用者自己决定

4.如果参数size为0,malloc的行为是标准未定义的,取决于编译器

//malloc实际使用
#include<stdio.h>
//头文件
#include<stdlib.h>
int main(void)
{
  //假设开5个int整型大小的空间
  int num = 5;
  int* pstr = (int*)malloc(sizeof(int) * num);
  //判断是否开辟成功
  if (pstr == NULL)
  {
    perror("Malloc fail");
    return;
  }
  //存储数据
  int i = 0;
  for (i = 0; i < num; i++)
  {
    pstr[i] = i;
  }
  //打印
  for (i = 0; i < num; i++)
  {
    printf("%d ", pstr[i]);
  }
  return 0;
}

  • 注意malloc函数在堆区开辟完空间之后需要释放

free

  • free函数介绍:

void free (void* ptr)

解放动态开辟的内存:释放被malloc,calloc,realloc函数开辟的内存块,以便为了以后再次的内存开辟

  • 头文件:#include<stdlib.h>
  • 参数ptr:被malloc,calloc,realloc函数开辟的内存所指向的指针
  • 返回值:none

注意事项:

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

2.如果参数ptr是NULL指针,则函数不做任何事

  • 实际使用
#define  _CRT_SECURE_NO_WARNINGS 1  
//free实际使用
#include<stdio.h>
//头文件
#include<stdlib.h>
int main(void)
{
  //假设开5个int整型大小的空间
  int num = 5;
  int* pstr = (int*)malloc(sizeof(int) * num);
  //判断是否开辟成功
  if (pstr == NULL)
  {
    perror("Malloc fail");
    return;
  }
  free(pstr);
  pstr = NULL;
  return 0;
}

calloc

  • calloc函数介绍:

void* calloc (size_t num, size_t size)

分配初始化为零的内存:为 num 元素数组分配一个内存块,每个元素的字节大小为字节长,并将其所有位初始化为零

  • 头文件:#include<stdlib.h>
  • 参数num:要分配的num个元素
  • 参数size:每个元素的大小

注意事项:

malloc申请到的空间,没有初始化直接返回起始地址;calloc申请号空间后,会把空间初始化为0,然后返回起始地点

  • 实际使用:
//calloc实际使用
#include<stdio.h>
//头文件
#include<stdlib.h>
int main(void)
{
  int num = 5;
  int* pstr = (int*)calloc(num, sizeof(int));
  if (pstr == NULL)
  {
    perror("Calloc fail");
    return;
  }
  //打印
  int i = 0;
  for (i = 0; i < num; i++)
  {
    printf("%d ", pstr[i]);
  }
  //释放内存
  free(pstr);
  pstr = NULL;
  
  return 0;
}
  • 运行结果

realloc

  • realloc函数介绍:

void* realloc(void* ptr ,size_t szie)

重新分配内存块:更改 ptr 指向的内存块的大小

  • 头文件:#include<stdlib.h>
  • 参数ptr:ptr是要调整的内存指针
  • 参数size:size是调整之后的新大小
  • 返回值:调整之后的内存起始位置

注意事项:

1.这个函数调整原内存空间大小的基础上,还会将原来内存中的数据移动到新的空间

2.realloc函数的出现让动态内存管理更加灵活

3.realloc函数可以做到对动态开辟内存大小的调整

4.realloc函数在扩容失败直接返回NULL

  • realloc在调整内存空间存在俩种情况:

(1)情况1:原有空间之后有足够大的空间,此时直接在后边续上新的空间,返回旧的起始地址

(2)情况2:当后面没有足够的空间可以扩容,realloc函数会找一个满足空间大小的新的连续空间,把旧的空间的数据,拷贝新空间的前面的位置,并且把旧的空间释放,同时返回新的空间的地址

  • realloc实际使用:
//realloc实际使用
#include<stdio.h>
//头文件
#include<stdlib.h>
int main(void)
{
  //设置原有空间大小
  int num = 5;
  int* pstr = (int*)malloc(sizeof(int) * num);
  if (pstr == NULL)
  {
    perror("Malloc fail");
    return;
  }
  //存放数据
  int i = 0;
  for (i = 0; i < num; i++)
  {
    pstr[i] = i;
  }
  //打印
  for (i = 0; i < num; i++)
  {
    printf("%d ",pstr[i]);
  }
  printf("\n");
  //扩容
  int* p = (int*)realloc((void*)pstr, sizeof(int) * num * 2);
  if (p == NULL)
  {
    perror("Realloc fail");
    return;
  }
  pstr = p;
  p = NULL;
  //赋值
  for (i = num; i < num * 2; i++)
  {
    pstr[i] = 5;
  }
  //打印
  for (i = 0; i < num * 2; i++)
  {
    printf("%d ",pstr[i]);
  }
  free(pstr);
  pstr = NULL;
  return 0;
}
  • 运行结果:

常见动态内存的错误

  • 对NULL解引用操作
void test()
{
  int* p = (int*)malloc(4);
  *p = 20;
  //如果p的值是NULL,就会有问题
  free(p);
}
  • 对动态开辟空间的越界访问
void test()
{
  int i = 0;
  int* p = (int*)malloc(10 * sizeof(int));
  if (NULL == p)
  {
    perror("Malloc fail");
  }
  for (i = 0; i <= 10; i++)
  {
    *(p + i) = i;
    //当i是10的时候越界访问
  }
  free(p);
  p = NULL;
}
  • 对非动态开辟内存使用free释放
void test()
{
  int a = 10;
  int* p = &a;
  free(p);
}
  • 使用free释放动态开辟的一部分
void test()
{
  int* p = (int*)malloc(100);
  p++;
  free(p);
  //p不再指向动态内存的起始位置
}
  • 对同一块动态内存多次释放
void test()
{
  int* p = (int*)malloc(100);
  free(p);
  free(p);
  //重复释放
}
  • 动态开辟内存之后忘记释放(内存释放)
void test()
{
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
 *p = 20;
 }
}
int main()
{
 test();
 while(1);
}

忘记释放不再使用的动态开辟的内存会造成内存泄露,所以切记动态内存一定要释放,并且需要正确释放

  • C\C++程序内存区域划分

  • C\C++程序内存分配的几个区域

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

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

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

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

实际上普通的局部变量实是在栈区分配空间的,栈区的特点是在上面创建变量,出了作用域就会销毁。但是被static修饰的变量存放在数据段(静态区)数据段的特点是在上面创建的变量,知道程序结合才销毁,所以生命周期更长

柔性数组(C99)

  • 结构中最后一个元素允许是未知大小的数组
struct s
  {
    int n;
    char c;
    char str[];//或者char str [0]
    //数据的大小是未知的(柔性数组成员)
  }

柔性数组的特点:

  • 结构中的柔性数组成员前面必须至少一个其他成员
  • sizeof返回的这种结构大小不包括柔性数组的内存
  • 包含柔性数组成员的结构用malloc()函数进行内存的动态分配,并且分配的内存应该大于结构的大小,以适应柔性数组的预期大小

柔性数组的优势:

  • 方便内存释放
  • 有利于访问速度
//柔性数组
#include<stdio.h>
#include<stdlib.h>
int main(void)
{
  struct stu
  {
    int i;
    int* pa;
  }stu;
  struct stu* p = malloc(sizeof(stu));
  if (p == NULL)
  {
    perror("malloc fail\n");
    return;
  }
  p->i = 100;
  p->pa = (int*)malloc(p->i * sizeof(int));
  if (p->pa == NULL)
  {
    perror("malloc fail\n");
    return;
  }
  //释放
  free(p->pa);
  p->pa = NULL;
  free(p);
  p = NULL;
  return 0;
}


相关文章
|
5天前
|
程序员
动态内存管理
动态内存管理
9 0
|
11月前
|
C语言 Python
动态内存管理(下)
动态内存管理(下)
53 0
|
4月前
|
程序员
21.动态内存管理
21.动态内存管理
|
5月前
|
程序员 C语言 C++
详解动态内存管理!
详解动态内存管理!
|
5月前
|
存储 安全 算法
c++动态内存管理(一)
C++ 动态内存管理 在 C++ 中,动态内存管理是一个核心概念,它允许在运行时分配和释放内存。以下是 C++ 动态内存管理需要掌握的关键知识点:
161 0
|
10月前
|
编译器
动态内存管理(1)
动态内存管理(1)
56 0
|
10月前
|
程序员 编译器 C语言
动态内存管理(2)
动态内存管理(2)
46 0
|
10月前
|
程序员 编译器 C语言
动态内存管理总结
动态内存管理总结
53 0
|
11月前
|
C语言 C++
C++中的动态内存管理
C++中的动态内存管理