C语言超详细梳理总结动态内存管理

2024-12-06 04:37:20

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

我们已经掌握的内存开辟方式有：

int a = 10；//在栈空间开辟4个字节的连续空间

int b[20] = { 0 };//在栈空间开辟20个字节的连续空间

这种开辟空间的方式有以下特点：

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

2.开辟数组时必须指定大小

初学数组时，我写过下面的错误代码。

int N;
scanf("%d",&N);
int a[N]={ 0 };

可N是变量，不能用于数组元素个数的初始化。

如果我们需要的空间大小在程序运行时才能知道，那就只能试试动态内存开辟了。

二.动态内存函数的介绍

1.malloc和free

void* malloc (size_t size);void free (void* ptr);

malloc函数用于向内存申请一块连续可用的空间，并且返回指向这块空间的指针。

若开辟成功，返回指向这块空间的指针

若开辟失败，返回NULL指针，因此malloc的返回值一定要做检查

使用完malloc函数要用free释放申请的内存空间

#include<stdio.h>#include<stdlib.h>int main(){int* p = (int*)malloc(40);//开辟40个字节的栈空间if (p == NULL)            //检查是否为空指针{perror("malloc");return 1;}for (int i = 0; i < 10; i++){*(p + i)=i;}free(p);                 //用完后释放空间，注意参数为首地址p = NULL;                //置为空指针}

2.calloc

void* calloc (size_t num, size_t size)

calloc的两个参数分别为申请元素的个数和每个元素的大小，

使用和malloc差不多，但是申请的空间会被初始化为0，

#include<stdio.h>#include<stdlib.h>int main(){int* p = (int*)calloc(10, sizeof(int));if (p == NULL){perror("calloc");return 1;}for (int i = 0; i < 10; i++){printf("%d  ", *(p + i)); //输出为 10个0}free(p);p = NULL;}

3.realloc

void* realloc (void* ptr, size_t size)

realloc用于重新设置要开辟内存空间的大小，可以是增大或减小

指针ptr是指向先前使用 malloc、calloc 或 realloc 分配的内存块的指针。

size 是新开辟内存空间的大小

若原空间后面未开辟的空间足够使用，则返回原先的起始地址

若原空间后面未开辟的空间不足以填满新开辟内存空间，

则会在某个地址开辟所需要的空间，free掉原空间的地址，

并且返回新的地址的起始地址

真 · 一条龙服务

若扩容失败，会返回空指针，因此也要检查是否是空指针

三.常见的动态内存错误

1.对NULL指针的解引用操作

void test(){    int *p = (int*)malloc(INT_MAX/4);    *p = 20;    free(p);}

若p为空指针，则程序错误。

解决方案：检查是否为空指针

2.对动态开辟空间的越界访问

int main(){int* p = (int*)calloc(10, sizeof(int));if (p == NULL){perror("calloc");return 1;}for (int i = 0; i <= 10; i++)  //当i为10时，形成越界访问，程序出错{printf("%d  ", *(p + i));}free(p);p = NULL;}

使用这块空间时要注意是否已经越界访问

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

    int a = 10;int* p = &a;free(p);

一执行，程序崩溃了

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

void test(){int* p = (int*)malloc(100);p++;free(p);}

同样会崩溃

5.对同一块开辟的空间多次释放

void test(){int* p = (int*)malloc(100);free(p);free(p);}

没错，又又又崩溃了，就不上图了

6.动态内存开辟忘记释放（内存泄漏）

如果使用空间后不释放，会导致内存泄漏。

内存泄漏的堆积，这会最终消耗尽系统所有的内存。

四.几个经典的笔试题 1.

void GetMemory(char* p)            //对空指针解引用{p = (char*)malloc(100);        //内存泄露}void test(){char* str = NULL;GetMemory(str);strcpy(str, "hello world");    printf(str);}int main(){test();}

p是str的一份临时拷贝，指向malloc申请的起始地址，

出了函数之后，内存还给系统，str仍为空指针，strcpy把“hello world”放进空指针

char *GetMemory(void){char p[] = "hello world";return p;}void test(){char* str = NULL;str=GetMemory(); //野指针strprintf(str);}int main(){test();}

定义字符串p，并返回p的地址

但是当出了这个函数，内存还给系统，没有使用权限

指针变为

void GetMemory(char** p,int num) //传址调用{*p = (char*)malloc(num); }void test(){char* str = NULL;GetMemory(&str,100);strcpy(str, "hello world");printf(str); //没有free}int main(){test();}

打印hello world

没有释放空间

void GetMemory(char** p,int num){*p = (char*)malloc(num);}void test(){char* str = (char*)malloc(100);strcpy(str, "hello world");free(str); //还给你，我还要用,哼~if (str != NULL){strcpy(str, "!!!");printf(str);}}int main(){test();}

开辟100个字节的空间后，又把这块空间还给操作系统。

再次把“！！！”放进这块空间，非法修改

tips：动态内存管理是在堆区上进行的。

详解C语言之动态内存管理

目录开辟动态内存的函数释放开辟的动态内存空间的函数错误信息函数具体使用例: 常见的动态内存错误总结先来了解一下动态管理内存所需用到的函数开辟动态内存的函数 1.malloc函数:void* malloc(size_t size); 功能:开辟一块大小为size单位为字节的动态空间.若开辟成功返回函数开辟空间的无类型指针,若开辟失败则返回空指针NULL 2.calloc函数: void* calloc(size_t num, size_t size); 功能:开辟一块能容纳下num个
C语言初识动态内存管理malloc calloc realloc free函数

目录一.为什么存在动态内存分配二.动态内存函数的使用 1.malloc函数 (1)malloc的定义 (2)malloc函数的注意事项 (3)malloc函数的使用 2.calloc函数 (1)calloc函数的定义 (2)calloc函数的注意事项 (3)calloc函数的使用 3.realloc函数 (1)realloc函数的定义 (2)realloc函数的注意事项 (3)realloc函数的使用总结一.为什么存在动态内存分配在c语言中我们目前掌握的内存开辟方式有: int val
C语言动态内存管理的实现

目录 1. 摘要 2. 为什么存在动态内存管理 3. 动态内存函数 3.1 malloc 3.2 free 3.3 calloc 3.4 realloc 4. 常见的动态内存错误 5. 几个经典笔试题参考答案 6. 参考文献 1. 摘要本文主要详解C语言中的动态内存分配 2. 为什么存在动态内存管理我们先来看一段变量的声明: double x = 1.000000; char str[] = "abcdef"; 好的,上述变量的声明有何特点呢? 请思考一下,我的朋友. 对,没错,
关于C语言动态内存管理介绍

目录 1.为什么需要动态内存分配 2.有关动态内存函数介绍 2.1 malloc和free 2.2 calloc函数 2.3 realloc函数 3. 常见的动态内存错误 3.1 对NULL指针进行解引用操作 3.2 对动态开辟空间的越界访问 3.3 对非动态开辟内存使用free释放 3.4 使用free释放一块动态开辟内存的一部分 3.5 对同一块动态内存多次释放 3.6 动态开辟内存忘记释放(内存泄漏) 总结 1.为什么需要动态内存分配关于这个问题,我们先看看我们之前是如何开辟内存的. i
C语言动态内存管理分析总结

目录什么是动态内存分配动态内存函数的介绍 free malloc calloc realloc 动态内存管理中常见的错误对NULL指针的解引用操作对动态开辟空间的越界访问对非动态开辟内存使用free释放使用free释放一块动态开辟内存的一部分对同一块动态内存多次释放动态开辟内存忘记释放(内存泄漏) 一些经典的笔试题题目1 题目2 题目3 题目4 柔性数组柔性数组的特点柔性数组的优势什么是动态内存分配我们都知道在C语言中,定义变量的时候,系统就会为这个变量分配内存空间,而
C语言动态内存管理介绍

目录前言: C 语言为内存的分配和管理提供了几个函数: 1.malloc() 用法 2.calloc() 用法 3.realloc() 与 free() 用法前言: 简单记录一下,内存管理函数为什么使用动态内存呢? 简单理解就是可以最大限度调用内存用多少生成多少,不用时就释放而静止内存不能释放动态可避免运行大程序导致内存溢出 C 语言为内存的分配和管理提供了几个函数: 头文件:<stdlib.h> 注意:void * 类型表示未确定类型的指针 1.malloc() 用法分配一块
C语言的动态内存管理的深入了解

目录一.动态内存分配二.动态内存分配函数 1.malloc() 2.realloc() 3.calloc() 三.用free函数释放内存四.迷途指针总结一.动态内存分配 (1)用malloc类的函数分配内存: (2)用这些内存支持应用程序: (3)用free函数释放内存. 内存的简答来说的三大操作:分配----使用----释放内存管理指的是:分配— ----释放我们编写的程序代码:使用程序本质上就是处理数据,数据信息需要存放在内存里,就是用二极管表示的开断表示二进制数,进一步用二
C语言超详细梳理总结动态内存管理

目录一.为什么存在动态内存分配二.动态内存函数的介绍 1.malloc和free 2.calloc 3.realloc 三.常见的动态内存错误 1.对NULL指针的解引用操作 2.对动态开辟空间的越界访问 3.对非动态开辟的空间使用free释放 4.使用free释放一块动态开辟空间的一部分 5.对同一块开辟的空间多次释放 6.动态内存开辟忘记释放(内存泄漏) 四.几个经典的笔试题一.为什么存在动态内存分配我们已经掌握的内存开辟方式有: int a = 10://在栈空间开辟4个字节的连续
C语言超详细梳理总结动态内存管理

目录一.为什么存在动态内存分配二.动态内存函数的介绍 1.malloc和free 2.calloc 3.realloc 三.常见的动态内存错误 1.对NULL指针的解引用操作 2.对动态开辟空间的越界访问 3.对非动态开辟的空间使用free释放 4.使用free释放一块动态开辟空间的一部分 5.对同一块开辟的空间多次释放 6.动态内存开辟忘记释放(内存泄漏) 四.几个经典的笔试题 1. 一.为什么存在动态内存分配我们已经掌握的内存开辟方式有: int a = 10://在栈空间开辟4个字节
C语言超详细梳理排序算法的使用

目录排序的概念及其运用排序的概念排序运用插入排序直接插入排序希尔排序选择排序直接选择排序堆排序交换排序之冒泡排序总结排序的概念及其运用排序的概念排序:所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作. 稳定性:假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变,即在原序列中,r[i]=r[j],且r[i]在r[j]之前,而在排序后的序列中,r[i]仍在r[j]之前,则称这种排序算法
超详细分析C语言动态内存管理问题

目录一.为什么存在动态内存的分配二.动态内存函数的介绍 2.1 malloc和free 2.2 calloc 2.3 realloc 三.常见的动态内存错误 3.1 对NULL指针的解引用操作 3.2 对动态开辟空间的越界访问 3.3 对非动态开辟内存使用free释放 3.4 对同一块动态内存多次释放 3.5 动态开辟内存忘记释放(内存泄漏) 四.几个经典的笔试题五.C/C++程序的内存开辟六.柔性数组 6.1 柔性数组的特点 6.2 柔性数组的使用 6.3 柔性数组的优势上期结束了[
C语言自定义类型超详细梳理之结构体枚举联合体

目录一.什么是结构体 1.结构体实现 2.匿名结构体类型 3.结构体自引用 4.结构体的内存对齐 5.结构体位段二.什么是枚举 1.枚举类型的定义 2.枚举的优点三.联合(共用体) 1.什么是联合(共用体) 2.联合(共用体)的定义 3.联合(共用体)的初始化总结一.什么是结构体结构是一些值的集合,这些值称为成员变量.结构的每个成员可以是不同类型的变量. //结构体声明 struct tag //struct:结构体关键字,tag:标签名,合起来是结构体类型(类型名) { memb
C语言语义陷阱超详细梳理总结

目录 1 指针与数组 2 非数组的指针 3 作为参数的数组声明 4 空指针并非空字符串 5 边界计算与不对称边界 6 求值顺序 7 整数溢出 8 为函数提供返回值 1 指针与数组 C语言中只有一维数组.数组中的元素可以是任意类型的对象,这也是多维数组构建的理论基础所在对于一个数组,我们只能做两件事:确定该数组的大小以及获得该数组下标为0的元素的指针.任何一个数组下标运算都等同于一个对应的指针运算. 数组名代表首元素的地址,无法对其进行++或者–操作,换句话说,我们无法改变数组名(表示的值),因
C语言超详细讲解字符串函数和内存函数

目录字符串函数长度不受限制的字符串函数 strlen strcpy strcat strcmp 长度受限制的字符串函数介绍 strncpy strncat strncmp 字符串查找以及错误报告 strstr strtok strerror 内存操作函数 memcpy memmove memcmp 字符串函数长度不受限制的字符串函数 strlen size_t strlen ( const char * str ) 求字符串长度: 字符串以'\0' 作为结束标志,strlen函数返回的是在
C语言超详细模拟实现单链表的基本操作建议收藏

目录 1 链表的概念及结构 2 链表的分类 3 链表的实现无头+单向+非循环链表增删查改实现 3.1 链表的定义 3.2 链表数据的打印 3.3 链表的尾插 3.4 链表空间的动态申请 3.5 链表的头插 3.6 链表的尾删 3.7 链表的头删 3.8 链表任意位置的前插入 3.9 链表任意位置的后插入 3.10 链表的任意位置的删除 3.11 链表的任意位置的前删除 3.12 链表的任意位置的后删除 3.13 链表的销毁 3.14 链表的总结 1 链表的概念及结构概念:链表是一种物理存储结构
C语言超详细顺序表的模拟实现实例建议收藏

目录概念及结构接口实现 1 顺序表的动态存储 2 顺序表初始化 3 顺序表的销毁 4 顺序表的尾插 5 顺序表的尾删 6 顺序表的头插 7 顺序表的头删 8 顺序表容量的检查与扩容 9 顺序表任意位置的插入 10 顺序表任意位置的删除 11 顺序表的打印 12 顺序表元素的查找 13 顺序表元素的修改概念及结构顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储.在数组上完成数据的增删查改. 顺序表一般可以分为: 静态顺序表:使用定长数组存储元素,元素
C语言超详细讲解算法的时间复杂度和空间复杂度

目录 1.前言 1.1 什么是数据结构? 1.2 什么是算法? 2.算法效率 2.1 如何衡量一个算法的好坏 2.2 算法的复杂度 2.3 复杂度在校招中的考察 3.时间复杂度 3.1 时间复杂度的概念 3.2 大O的渐进表示法 3.3 常见时间复杂度计算举例 4.空间复杂度 5. 常见复杂度对比 1.前言 1.1 什么是数据结构? 数据结构(Data Structure)是计算机存储.组织数据的方式,指相互之间存在一种或多种特定关系的数据元素的集合. 1.2 什么是算法? 算法(Algorit