前言
本篇博客就来探讨一下动态内存,说到内存,我们以前开辟空间大小都是固定的,不能调整这个空间大小,于是就有动态内存,可以让我们自己选择开辟多少空间,更加方便,让我们一起来看看动态内存的有关知识吧
个人主页:小张同学zkf
若有问题 评论区见
感兴趣就关注一下吧
目录
1.什么是动态内存
2. malloc和free
2.1 malloc
2.2 free
3. calloc和realloc
3.1 calloc
3.2 realloc
4. 常见的动态内存的错误
4.1 对NULL指针的解引用操作
4.2 对动态开辟空间的越界访问
4.3 对非动态开辟内存使用free释放
4.4 使用free释放一块动态开辟内存的一部分
4.5 对同一块动态内存多次释放
4.6 动态开辟内存忘记释放(内存泄漏)
5. 动态内存经典笔试题分析
5.1 题目1:
5.2 题目2:
5.3 题目3:
5.4 题目4:
6. 柔性数组
6.1 柔性数组的特点:
6.2 柔性数组的使用
6.3 柔性数组的优势
1.什么是动态内存
首先我们要搞清楚什么是动态内存的分配?
平常我们定义的数组,都是在栈区分配的空间,都是分配的空间都是固定的大小
这种分配固定大小的内存分配方法称之为静态内存分配
与静态内存相对的,就是可以控制内存的分配的动态内存分配
注意:这里动态内存分配的空间是在堆区申请的,不是在栈区申请的
我们再来看看内存各个空间都是什么
2. malloc和free
我们来了解下动态内存的函数,对了以下所有函数的头文件都是<stdlib.h>
2.1 malloc
C语言提供了一个动态内存开辟的函数:
void * malloc ( size_t size);
这个函数向内存申请一块连续可用的空间,并返回指向这块空间的指针。
注意:
• 如果开辟成功,则返回一个指向开辟好空间的指针。• 如果开辟失败,则返回一个 NULL 指针,因此malloc的返回值一定要做检查。• 返回值的类型是 void* ,所以malloc函数并不知道开辟空间的类型,具体在使用的时候使用者自己来决定。• 如果参数 size 为0,malloc的行为是标准是未定义的,取决于编译器
2.2 free
void free ( void * ptr);
#include <stdio.h>
#include <stdlib.h>
int main()
{
int num = 0;
scanf("%d", &num);
int arr[num] = {0};
int* ptr = NULL;
ptr = (int*)malloc(num*sizeof(int));
if(NULL != ptr)//判断ptr指针是否为空
{
int i = 0;
for(i=0; i<num; i++)
{
*(ptr+i) = 0;
}
}
free(ptr);//释放ptr所指向的动态内存
ptr = NULL;//是否有必要?
return 0;
}
看这个例子就是典型的动态内存的开辟和回收,malloc开辟空间,然后判断一下是不是开辟空间失败,若失败返回空指针,当动态内存你使用完毕之后,用free释放,释放后的指针是野指针,记得置空。
3. calloc和realloc
3.1 calloc
void * calloc ( size_t num, size_t size);
#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p = (int*)calloc(10, sizeof(int));
if(NULL != p)
{
int i = 0;
for(i=0; i<10; i++)
{
printf("%d ", *(p+i));
}
}
free(p);
p = NULL;
return 0;
}
输出结果:
0 0 0 0 0 0 0 0 0 0
所以如果我们对申请的内存空间的内容要求初始化,那么可以很方便的使用calloc函数来完成任务。
3.2 realloc
void * realloc ( void * ptr, size_t size);
#include <stdio.h>
#include <stdlib.h>
int main()
{
int *ptr = (int*)malloc(100);
if(ptr != NULL)
{
//业务处理
}
else
{
return 1;
}
//扩展容量
//代码1 - 直接将realloc的返回值放到ptr中
ptr = (int*)realloc(ptr, 1000);//这样可以吗?(如果申请失败会如何?)
//代码2 - 先将realloc函数的返回值放在p中,不为NULL,在放ptr中
int*p = NULL;
p = realloc(ptr, 1000);
if(p != NULL)
{
ptr = p;
}
//业务处理
free(ptr);
return 0;
}
realloc在vs上,是情况2的情况,自动释放旧的动态空间,在新的动态空间里开辟更大的空间,自动把就空间的数据拷贝一份到新空间,返回新空间的初始指针,所以不用再用free释放旧空间,只需释放realloc开批的新空间,记住realloc开辟的新空间也有可能开辟失败,若开辟失败,返回空指针。
4. 常见的动态内存的错误
4.1 对NULL指针的解引用操作
void test (){int *p = ( int *) malloc (INT_MAX/ 4 );*p = 20 ; // 如果 p 的值是 NULL ,就会有问题free (p);}
看这个代码,这个动态内存开辟的空间没有判断p是不是空指针,有可能内存开辟失败返回空指针,若对空指针解引用,就会非法访问出错。
4.2 对动态开辟空间的越界访问
void test (){int i = 0 ;int *p = ( int *) malloc ( 10 * sizeof ( int ));if ( NULL == p){exit (EXIT_FAILURE);}for (i= 0 ; i<= 10 ; i++){*(p+i) = i; // 当 i 是 10 的时候越界访问}free (p);}
仔细看这个i,当它等于10时,已经不算动态内存的开辟访问的空间范围内,是越界访问,
4.3 对非动态开辟内存使用free释放
void test (){int a = 10 ;int *p = &a;free (p); //ok?}
这个free只能对动态内存的空间释放,注意这一点
4.4 使用free释放一块动态开辟内存的一部分
void test (){int *p = ( int *) malloc ( 100 );p++;free (p); //p 不再指向动态内存的起始位置}
这个p指针发生改变,不在指向动态内存的起始位置,释放时只释放p现在指向的位置空间,所以只释放一部分,另一部分没释放,造成内存泄漏
4.5 对同一块动态内存多次释放
void test (){int *p = ( int *) malloc ( 100 );free (p);free (p); // 重复释放}
一个动态内存的开辟只能释放一次,不能多次释放
4.6 动态开辟内存忘记释放(内存泄漏)
void test (){int *p = ( int *) malloc ( 100 );if ( NULL != p){*p = 20 ;}}int main (){test();while ( 1 );}
这个test函数返回时,函数空间释放,所以找不到动态内存的的地址了,但动态内存空间还没释放,并且也释放不了,就成为内存泄露的问题
5. 动态内存经典笔试题分析
5.1 题目1:
void GetMemory ( char *p){p = ( char *) malloc ( 100 );}void Test ( void ){char *str = NULL ;GetMemory(str);strcpy (str, "hello world" );printf (str);}
当这个GetMemory函数返回时,函数空间释放,访问不到动态内存的空间了。但动态内存没释放,形成内存泄漏,由于形参是实参的临时拷贝,不影响str依旧是空指针,对空指针访问,程序崩溃
5.2 题目2:
char * GetMemory ( void ){char p[] = "hello world" ;return p;}void Test ( void ){char *str = NULL ;str = GetMemory();printf (str);}
首先注意这个GetMemory函数里是栈空间的变量数组,随着函数的释放,这个变量的空间也会释放,你虽然返回了数组首元素的地址,但是这个空间已经交还给系统,无权访问了,是野指针,所以我不确定到底能不能再次访问到这个数组,有可能还没有被系统把这个空间覆盖成其他内容,有可能访问到
5.3 题目3:
void GetMemory ( char **p, int num){*p = ( char *) malloc (num);}void Test ( void ){char *str = NULL ;GetMemory(&str, 100 );strcpy (str, "hello" );printf (str);}
这个是传str地址过去,是传址调用,那就用二级指针的形参接收,对二级指针解引用,将动态内存的首地址通过传址调用,让str接收到,所以此刻虽函数空间释放了,但我的动态内存的首地址拿到了,所以此刻这个str不是空指针了,可以strcpy,但可惜这个代码最终忘记释放str了,只有这一个小问题
5.4 题目4:
void Test ( void ){char *str = ( char *) malloc ( 100 );strcpy (str, "hello" );free (str);if (str != NULL ){strcpy (str, "world" );printf (str);}}
提早释放动态内存,但是只是对这个动态内存的空间没有访问的权限了,地址还是在的,通过strcpy,访问了动态内存的空间,这就是非法访问了,也就是说在没释放前,hello被拷贝过去,释放后,world无法拷贝过去
6. 柔性数组
struct st_type{int i;int a[ 0 ]; // 柔性数组成员};
有些编译器会报错无法编译可以改成:
struct st_type{int i;int a[]; // 柔性数组成员};
6.1 柔性数组的特点:
typedef struct st_type{int i;int a[ 0 ]; // 柔性数组成员}type_a;int main (){printf ( "%d\n" , sizeof (type_a)); // 输出的是 4return 0 ;}
6.2 柔性数组的使用
// 代码 1# include <stdio.h># include <stdlib.h>int main (){int i = 0 ;type_a *p = (type_a*) malloc ( sizeof (type_a)+ 100 * sizeof ( int ));// 业务处理p->i = 100 ;for (i= 0 ; i< 100 ; i++){p->a[i] = i;}free (p);return 0 ;}
这样柔性数组成员a,相当于获得了100个整型元素的连续空间。
6.3 柔性数组的优势
// 代码 2# include <stdio.h># include <stdlib.h>typedef struct st_type{int i;int *p_a;}type_a;int main (){type_a *p = (type_a *) malloc ( sizeof (type_a));p->i = 100 ;p->p_a = ( int *) malloc (p->i* sizeof ( int ));// 业务处理for (i= 0 ; i< 100 ; i++){p->p_a[i] = i;}// 释放空间free (p->p_a);p->p_a = NULL ;free (p);p = NULL ;return 0 ;}
如果我们的代码是在一个给别人用的函数中,你在里面做了二次内存分配,并把整个结构体返回给用户。用户调用free可以释放结构体,但是用户并不知道这个结构体内的成员也需要free,所以你不能指望用户来发现这个事。所以,如果我们把结构体的内存以及其成员要的内存一次性分配好了,并返回给用户一个结构体指针,用户做一次free就可以把所有的内存也给释放掉。
连续的内存有益于提高访问速度,也有益于减少内存碎片。(其实,我个人觉得也没多高了,反正你跑不了要用做偏移量的加法来寻址)
结束语
动态内存的存储算是总结完了,动态内存我个人感觉也算是比较难,有点绕,可以多来回看看这篇博客,有什么问题跟我讨论,下一篇博客见
OK感谢观看!!!文章来源:https://www.toymoban.com/news/detail-852639.html
文章来源地址https://www.toymoban.com/news/detail-852639.html
到了这里,关于【C语言】动态内存的管理的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!