动态内存管理详细介绍

最新推荐文章于 2024-03-23 01:03:26 发布
最新推荐文章于 2024-03-23 01:03:26 发布
阅读量1.3k 收藏 13
点赞数 21
分类专栏： c/c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51723227/article/details/116999764
版权

文章目录

1.为什么存在动态内存分配?

目前为止,我们已经掌握的内存开辟方式有两个,且知道在内存中,我们主要使用的是 栈区,堆区,静态区.其中三者的作用分别如下:

（1）静态存储区：主要存放static静态变量、全局变量、常量。这些数据内存在编译的时候就已经为他们分配好了内存，生命周期是整个程序从运行到结束。

（2）栈区：存放局部变量。在执行函数的时候（包括main这样的函数），函数内的局部变量的存储单元会在栈上创建，函数执行完自动释放，生命周期是从该函数的开始执行到结束。

（3）堆区：程序员自己申请一块任意大小的内存—也叫动态内存分配。这块内存会一直存在知道程序员释放掉。C语言中，用malloc or new动态地申请内存，用free or delete释放内存。良好习惯：若申请的动态内存不再使用，要及时释放掉，否则会造成内存泄露

示例:

第一:创建局部变量,函数调用等

void print()
{
    char str[] = "I'm your father";
    printf("%s",str);
}

int main()
{
    int a = 0;   
    
    print();
    return 0;
}

例如上面,就是创建了局部变量 str和a,以及进行了函数调用.而他们是在 栈区使用内存

第二: 全局变量,常量等

int b = 20;
int main()
{
    const int c = 10;
    return 0;
}

例如上面,就是创建了 全局变量b,常量c, 而他们是在 静态区使用

但是上述的内存开辟方式却有两个特点:

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

  2. 数组在声明的时候,必须指定数组长度,且此后长度固定,无法修改.它所需要的内存在编译时进行分配

而最后剩下的一种----- 堆区,便是我们此篇文章的核心与主角.

**引言:**有时候我们需要的空间大小在程序运行的时候才能知道，那数组在编译时才开辟空间的方式就不能满足,这时候就只能试试动态存开辟,即使用 堆区内存

比如下面的例子:

struct info
{
    char name[20];
    int age;
};

int main()
{
    int n = 0;
    scanf("%d",&n);
    struct info arr[50];
    return 0;
}

上面的结构体 struct info是一个人(学生)的信息(姓名,年龄).下面创建了一个大小为50的数组arr用来存各个学生的信息.

但是我们难免会碰到一些情形,比如一些学生因为特殊原因不来上学,就不会记录信息.或者因为生源太好,名额超出50.那么最开始设置的50个名额,就不会够用,或者空间浪费.因此我们便需要对数组长度进行动态调整.

2.各种动态内存函数介绍

2.1 malloc

官方声明:void* malloc (size_t size)

  • size 需要开辟空间的字节大小
  • void* 开辟的空间的地址
2.1.1声明与解释

作用: 开辟一块数组空间,返回地址.

使用:

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

  • 如果开辟失败,则返回一个NULL指针,因此malloc的返回值必须检查

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

  • 如果参数 size为0，malloc的行为是标准是未定义的，取决于编译器。

2.1.2 使用

例子:

  1. 向内存申请10个整形空间
int* p = (int *)malloc(sizeof(int) * 10);

可以看见size的实参是 sizeof(int) * 10

最后返回时,指针void*被转化为整型指针.

  1. 在申请的时候可能也会申请失败,比如:
#include<stdio.h>
#include <stdlib.h>
int main()
{
    double* p = (double*)malloc(sizeof(double) * 1000000000000);
    if (p == NULL)
        perror("申请失败原因:");
    return 0;
}

结果:

image-20210518095118789

  1. 使用空间
#include<stdio.h>
#include <stdlib.h>
int main()
{
    int* p = (int*)malloc(sizeof(int) * 10);
    if (p == NULL)
        perror("申请失败原因:");
    else
    {
        for (int i = 0; i < 10; i++)
        {
            p[i] = i;
            printf("%d ",p[i]);
        }
    }
    return 0;
}

image-20210518100110813

上面已经介绍了如何在 堆区申请空间,判断申请是否成功,如何使用malloc .

但是我们最开始就说了,堆区申请的空间是 程序员自己手动释放,而放眼看前面,我们释放了吗??

并没有,因此,引出了下面的函数 free

2.2 free

上述已经学会了使用 malloc ,现在就应该还回去我们所申请的空间了.那怎么还回去呢? 答案是 使用 free函数

官方文档: void free(void *memblock);

memblock 需要释放的空间的地址

使用:

#include<stdio.h>
#include <stdlib.h>
int main()
{
    int* p = (int*)malloc(sizeof(int) * 10);
    if (p == NULL)
        perror("申请失败原因:");
    else
    {
        for (int i = 0; i < 10; i++)
        {
            p[i] = i;
            printf("%d ",p[i]);
        }
    }
    free(p);    // 成功释放
    return 0;
}

上面已经成功释放了,但是还有个小问题,比如我们在free后面和最开始申请空间语句后面加一条语句 printf("%p\n",p);

image-20210518102455618

会发现,申请的空间虽然被释放,但是p的值并没有改变,仍然记住了,此时p成了野指针,及其危险,所以我们需要在free(p)后面加上 p = NULL;

比如:

#include<stdio.h>
#include <stdlib.h>
int main()
{
    int* p = (int*)malloc(sizeof(int) * 10);
    if (p == NULL)
        perror("申请失败原因:");
    else
    {
        for (int i = 0; i < 10; i++)
        {
            p[i] = i;
            printf("%d ",p[i]);
        }
    }
    free(p);    // 成功释放
    p = NULL;    //置为空
    return 0;
}

助记:

此时的p就相当于男女朋友中的男生,当他们分手了以后,男生还记得女生的所有信息(p仍然记住了原地址) ,女生为了防止自己以后不被骚扰,就给了男的当头一棒,让男的失忆(p = NULL)

总结:

malloc,free,NULL 需要成对使用.

free函数用来释放的是动态开辟的内存,如果参数是指向非动态开辟的内存,那么free函数未定义.

如果free的参数是空指针NULL,则free函数什么也不做

2.3 calloc

calloc函数的用法与malloc很像,但是calloc比malloc函数多了一个功能---------可以在开辟空间时候,给数组每个位置初始化为0

官方文档: void* calloc (size_t num , size_t size);

num ------>>> 数组长度

size------>>> 数组元素类型的字节大小

开辟成功返回数组地址,不够返回NULL

示例:

#include <stdio.h>
#include <stdlib.h>
int main()
{
 	int* p = (int* )calloc(10,sizeof(int));  //申请空间
    if(p == NULL)                           //检测是否开辟失败
        perror("错误原因:");
    else
        for(int i = 0;i<10;i++)            //打印数组每个值
            printf("%d ",p[i]);
    free(p);                               //释放空间
    p = NULL;                              //置为空指针
    return 0;
}

image-20210518141307237

2.4 realloc (王者出场,真正的调整数组长度)

前面我们介绍了malloc与calloc,但是好像都是在申请一块空间,并没有与我们开头介绍的数组长度可变有半毛钱关系,于是顺应我们的要求,王者老大哥---------realloc出场.

realloc的出现使内存管理更加灵活,可以调整动态内存开辟的大小.

官方文档: void* realloc (void* memblock,size_t size)

  1. memblock 已经开辟的内存块的地址

  2. size 新的空间大小

  3. 开辟成功就会返回开辟的空间地址

  4. 失败就会返回NULL

  5. realloc的返回值需要用一个新的变量接收

示例:

#include <stdio.h>
#include <stdlib.h>
int main()
{
 	int* p = (int* )malloc(sizeof(int)*10);  //申请空间
    if(p == NULL)                           //检测是否开辟失败
        perror("错误原因:");
    else
        for(int i = 0;i<10;i++)            //打印数组每个值
            printf("%2d ",p[i] = i);
    printf("\n");
    
    
    //调整空间
	int* p1 = (int*) realloc(p, sizeof(int) * 20);
    if(p1 == NULL)              //检测开辟是否成
        perror("错误原因:");
    else
    {
        p = p1;      //重新交给p管理申请的空间
        for(int i = 10;i<20;i++)
            printf("%d ",p[i] = i);
    }
    
    
    free(p);                               //释放空间
    p = NULL;                              //置为空指针
    return 0;
}

image-20210518143140221

可以看见,之前malloc只开辟了10个长度,但是现在却可以有20个空间.

2.4.1 realloc的空间开辟方式

但是看了上面的使用示例,大家是否有什么疑问呢? 比如:

  • 为什么一定要用新的指针变量来接收realloc的

  • 后面为什么又重新交给原来的指针变量p

  • 释放空间时候,为什么只需要释放p,而不用管p1了.

在回答这几个问题之前我们需要知道realloc开辟空间的方式.以下面的图为例

image-20210518144945933

在堆区,空间占有比较混乱,如图中所示malloc已经成功开辟了一块空间,但是可以清晰的看到,在malloc开辟的地方和右上角其他占用地区中间还有一块小缝隙.在下方的两块其他占用区中间也有一块空白的地方.

而realloc对malloc申请的空间进行调整时候,会首先自动检测新的需要开辟的空间,如果直接跟在mallo后是否够用,比如下图:

image-20210518145638318

  1. 比如此时realloc还需要三个整型长度----------realloc (p, sizeof(int)*13); 检测到malloc后面还剩下4可用,于是便直接在其后追加三个空间,然后依然返回p的地址.

  2. 而倘若realloc还需要8个整型长度----------------realloc(p,sizeof(int)*18); 检测到malloc后面只有4个空间,并不够用,于是便再另起山头,在下面看到了一个可以开辟20整型长度的空地,于是便在这里重新开辟 18个整型空间,开辟好后,便把原malloc开辟空间内容拷贝一份放到新开辟的18个空间.然后返回新开辟的空间地址,返回时候,便同时自动释放掉原来malloc开辟的空间

  3. 倘若上面两种都开辟失败,就会返回NULL

因此,这就是我们为何说,一定要用新的指针接收realloc的返回值,因为如果开辟失败,非但没有得到新的空间,还返回了一个NULL给原来管理malloc开辟的空间的变量p,导致p无法再管理malloc. -------------这种危险写法p = (int*)realloc(p,sizeof(int)*18);

而如果开辟成功了,再重新把新的地址交给p管理,p就有两种可能.

  • 第一,仍然接管p原来空间(现在增大了)
  • 第二,接管了新的空间.

会发现,无论上面哪种情况,最后释放p时,都会完全释放两块空间(因为新开辟时候,会自动释放原malloc开辟空间).

3.常见的动态内存错误

示例1

int main()
{
     int *p = (int *)malloc(INT_MAX/4);
     for(int i = 0;i<10;i++)
         *(p+i) = i;
     free(p);
    return 0;
}

上面的例子有什么错误??

答案:

  1. 没有判断是否成功开辟空间,如果开辟失败p将会是NULL,那么后面的*(p+i) = i;就是在对 NULL指针进行解引用操作
  2. p最后未置为NULL,是不安全的,正如博主一开始写的男女朋友关系那个例子

示例2

int main()
{
    int i = 0;
    int *p = (int *)malloc(10*sizeof(int));
    if(NULL == p)
    {
    	perror("开辟失败原因:");
        return -1;
    }
    for(i=0; i<=10; i++)
    {
    	*(p+i) = i;
    }
    free(p);
    p = NULL;
    return 0;
}

上面的例子有什么错误??

答案:

数组越界,10个空间的数组,索引最大只能9.

示例3

int main()
{
    int a = 10;
    int *p = &a;
    free(p);
    p = NULL;
    return 0;
}

上面的例子有什么错误??

答案:

free前面已经讲到只能对管理堆区的内存进行释放,而这里的p管理的是栈区

小插曲:

| 之前忘记讲了,我们知道realloc是对动态开辟的内存进行管理,但是我们如果把realloc的第一个参数给一个NULL |

| 那么,此时的realloc就完全是个malloc , 比如 realloc(NULL, sizeof(int)*10) 等价于 malloc(sizeof(int) * 10)|

示例4

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)malloc(sizeof(int)*20);
	if (p != NULL)
	{
		for (int i = 0; i < 10; i++)
			*p++ = i;
	}
	free(p);
	p = NULL;
	return 0;
}

上面的例子有什么错误??

答案:

并没有完全释放堆区内存,下图进行解释

image-20210518155936487

在执行循环后,free释放的只是后面橙色的空间,黄色空间并没有释放.

示例5

int main()
{
    int *p = (int *)malloc(100);
    if(p == NULL) 
        perror("错误原因");
     else
     {
         for(int i= 0;i<25;i++)
             printf("%d ",p[i] = i);
     }
    free(p);
    ......  //省略几万行代码
    ......  //省略几万行代码  
    free(p);
    return 0;
}

上面的例子有什么错误??

答案:

多次释放同一块内存,原因是当代码功能过多时候,我们会忘记前面是否释放过,而导致重复释放.

第一次释放后,空间已经没有了,但是p还记忆着在堆区的原地址,再次释放,如果此时该地址其他东西被占用,将会导致内存管理出错,或者程序挂掉.

防止重复释放的解决办法: 每次释放后记得加 p = NULL,free对空指针NULL不做处理

示例6

int main()   
{
    while(1)
    {
        malloc(1);
    }
    return 0;
}

上面的例子有什么错误??

答案:

在疯狂的开辟空间,并没有还回去,导致自己不用了,别人也不能用(内存泄露).

这会导致整个计算机最后崩溃.

4.几个经典笔试题

题目一:

void GetMemory(char* p)
{
     p = (char *)malloc(100);
}

void Test(void)
{
     char *str = NULL;
     GetMemory(str);
     strcpy(str, "hello world");
     printf(str);
}

会出现什么结果???

答案:

程序会崩溃.原因:

GetMemory属于传值调用,不是传址调用.
即p虽然获取了堆区申请地址,可以进行管理,但由于GetMemory函数结束后,p的生命周期也就结束了.管理不了该空间,且下面用的还是str,不是p
最后,我们字符串拷贝的第一个参数是str,传值调用时,str的值并没有改变,仍然是NULL.
那么最后指针str还是一个空指针,便不能进行拷贝.程序出错.

其次,在函数GetMemory内部并没有释放内存.

怎么修改??

第一种改法:

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;
}

第二种改法:

char * GetMemory(char* p)
{
    p = (char *)malloc(100);
    return p;       //直接返回值.
}

void Test(void)
{
     char* str = NULL;
     str = GetMemory(str);  //用str接收
     strcpy(str, "hello world");
     printf(str);
}

题目二:

char *GetMemory(void)
{
     char p[] = "hello world";
     return p;
}

void Test(void)
{
     char *str = NULL;
     str = GetMemory();
     printf(str);
}

答案:

烫烫烫烫烫烫烫烫烫…

解析:

GetMemory函数内部的局部变量的地址是在栈区,当GetMemory函数调用结束,字符数组p的生命周期也就结束,里面的内容也不复存在.而其却返回了p的地址,因为不复存在,系统便给未初始化的栈空间一个中文GB2312编码中的0xccdd,正好对应 烫

怎么修改?

第一种改法:

char *GetMemory(void)
{
     static char p[] = "hello world";  //变为静态变量,延长生命周期
     return p;
}

void Test(void)
{
     char *str = NULL;
     str = GetMemory();
     printf(str);
}

第二种改法:

char *GetMemory(void)
{
    char* p = (char*)malloc(100);   //在堆区申请空间,他的生命周期就由程序员结束
    p = "hello world";
    return p;
}

void Test(void)
{
    char *str = NULL;
    str = GetMemory();
    printf(str);
    free(str);
    str = NULL;
}

题目三:

void Test(void)
{
     char *str = (char *) malloc(100);
     strcpy(str, "hello");
     free(str);
     if(str != NULL)
     {
         strcpy(str, "world");
         printf(str);
     }
}

答案:

world 原因,虽然提前释放了空间,但是 str会有记忆功能(前面说的男女朋友中的男性),所以还是会成功拷贝.

5.柔性数组

c99中,结构体中的最后一个元素允许是未知大小的数组,叫做柔性数组成员

image-20210518194021639

5.1具有柔性数组的结构大小计算:

struct stu
{
    int a;
    char c;
    int num[];
};

int main()
{
    printf("%d ",sizeof(struct stu));
    return 0;
}

答案:

结构体大小计算博主在自定义类型中已经讲解过, 这里的答案是8字节.会发现8字节只是前面两个成员所占据的空间,也就是说,含有柔型数组的结构体不会计算柔性数组的大小.其他计算方法与结构体一样

5.2 柔性数组的使用

使用malloc 开辟比 含有柔性数组的结构体的空间 更大的空间,多出的空间就是柔性数组的.比如下面

第一种使用方法:

typedef struct st_type
{
     int i;
     int a[0];//柔性数组成员
}type_a;

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);          //释放
    p = NULL;
    return 0;
}

第二种使用方法:

typedef struct st_type
{
     int i;
     int *p_a;
}type_a;

int main()
{
    type_a *p = 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;
}

上述两种使用方法可以完成同样的功能，但是 方法1 的实现有两个好处：

  • 第一个好处是：方便内存释放 如果我们的代码是在一个给别人用的函数中，方法二在里面做了二次内存分配，并把整个结构体返回给用户。用 户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个 结构体 指针，用户做一次free就可以把所有的内存也给释放掉。

  • 第二个好处是：这样有利于访问速度. 连续的内存有益于提高访问速度，也有益于减少内存碎片(前面说过堆区使用内存比较混乱,有很多空闲)。

总结

柔性数组的特点：

  • 结构中的柔性数组成员前面必须至少一个其他成员。
  • sizeof返回的这种结构大小不包括柔性数组的内存。
  • 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应 柔性数组的预期大小。
捕获一只小肚皮
关注
  • 21
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 11
    评论
专栏目录
动态内存管理详解
eternal_yy
11-29 3030
C语言中开辟内存有很多种方式，目前我们最常用的也就是数组，但数组是在我们用到他之前就得设定好它的长度，有时很不方便。 我们知道，c语言规定，不允许设定一个未知长度的数组。（但在Linux下可以设定，但也不支持这样做）下面这段代码就会报错哟！！！ int x = 5; int arr[x];  所以，为了填补这一缺口，c语言有了动态内存，c语言提供了几个函数来管理我们的动态内存，这几个函数...
数据结构与算法（C语言）
aiqq136的博客
01-26 5013
目录： 第一章： 数据结构绪论 1.什么是程序：程序 = 数据结构 + 算法 2.逻辑结构&物理结构的区别用法 基本的目标就是将数据及其逻辑关系存储到计算机的内存中 一：逻辑结构: 逻辑结构是指数据对象中数据元素之间的相互关系 逻辑结构是面向问题的 A:集合结构：数据元素除了同属于一个集合外，它们之间没有其他关系 B:线性结构：数据元素之间是一对一关系 C:树形结构：数据元素之间呈现一对多关系 D:图形结构：数据元素是多对多关系 二：物理结构 物理结构是指数据的逻辑结构在.
动态内存管理
yiyezhiqiuer的博客
01-06 159
动态内存管理
动态内存管理（超级详讲）
最新发布
djdjiejsn的博客
03-23 1688
一.为什么要有动态内存分配 二.动态内存开辟的函数：malloc 三.free函数 四.calloc函数 五.realloc函数 六.常见的动态内存错误 七.动态内存经典笔试题分析
动态内存管理（动态内存函数的介绍）
Adenson的博客
05-23 1216
在介绍动态内存开辟函数之前，先把动态内存释放函数（free）介绍一下，因为这个在一下几个函数中都会用到。 一、free（void free (void* ptr)） 1.专门是用来做动态内存的释放和回收的。 2.如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。 3. 如果参数 ptr 是NULL指针，则函数什么事都不做。 举个例子：free（ptr）;其中ptr必须是指...
C语言学习笔记（16）动态内存管理
qq_56663697的博客
07-25 275
文章目录为什么存在动态内存分配动态内存函数的介绍malloc和freecallocrealloc 为什么存在动态内存分配 我们已经掌握的内存开辟方式有: int va1 = 20;//在栈空间上开辟四个字节 char arr[10] = {0};//在栈空间上开辟10个字节的连续空间 但是上述的开辟空间的方式有两个特点: 空间开辟大小是固定的。 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。 但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，
C语言内存管理与联合结构课件笔记.md
08-25
本课件首先介绍了C语言中的内存管理知识,包括堆栈概念、动态内存分配函数及内存泄漏等问题,并给出了示例代码。然后详细讲解了C语言中的结构体与联合的定义、访问及嵌套使用,每部分都配有代码实例说明。内容结构清晰,...
操作系统专业课程设计连续动态分区内存管理模拟实现样本.doc
12-13
接着，我们介绍了开发环境和系统分析设计，并对内存管理理论进行了详细的阐述，包括内存管理概念、内存物理组织、虚拟内存等。然后，我们讨论了连续动态分区内存管理方式，包括单一连续分配、固定分区存储管理、可变...
深入理解C++中的new/delete和malloc/free动态内存管理及区别介绍
09-07
主要介绍了深入理解C++中的new/delete和malloc/free动态内存管理,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
操作系统内存管理(共53张PPT).pptx
11-16
本资源摘要将对操作系统内存管理的基本概念、内存硬件组织方法、内存管理技术、库链接和加载、内存保护、交换、内存分配等进行详细的介绍。 一、内存硬件组织方法 操作系统内存管理的第一步是了解内存硬件的组织...
计算机操作系统内存标准管理系统可变分区存储管理方式的内存分配回收.doc
12-18
本文将详细介绍可变分区存储管理方式的内存分配回收机制，并提供了一个完整的课程设计方案。 一、课程设计目标： 本课程设计的目标是深入了解可变分区存储管理方式的内存分配回收机制，并通过编写程序来实现该机制...
关于动态内存管理的一些理解
潜心钻研技术
08-13 684
动态内存管理 文章目录动态内存管理为什么要存在动态内存分配动态内存函数的介绍 为什么要存在动态内存分配 我们现在知道的开辟的空间的方式只有直接声明变量，例如： int a = 3; char b[5] = { 1,2,3 }; 我在学习数组的时候告诉我们定义数组时，例如：int a[n]。n必须时常量，而不能是变量。当时我就在想这样的规定是多么的不人性化，因为n是常量的时候，你必须在定时数组的时候就预先知道数组的大小，特别是在处理一些复杂的问题的时候数组的大小是变化的，当时我就在想为什么不能在
实验四 主存空间的分配和回收
weixin_30451709的博客
12-30 396
实验四主存空间的分配和回收模拟 .实验目的 为了合理地分配和使用这些存储空间，当用户提出申请主存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间和使用情况，找出足够的空闲区域给申请者。当作业撤离归还主存资源时，则存储管理要收回占用的主存空间。主存的分配和回收的实现是与主存储器的管理方式有关的，通过本实验帮助我们理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。...
第三章 内存管理
weixin_45360119的博客
01-03 1600
第三章 内存管理 3.1 内存管理概念 3.1.1 内存的基础知识 什么是内存？有何作用？ 程序执行前需要先放到内存中才能被CPU处理——缓和CPU与硬盘之间的速度矛盾 功能： 内存空间的分配与回收 地址转换 内存空间的扩充 存储保护 进程运行的基本原理 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4TANPMwA-1641173361227)(E:/txy/大三上/操作系统/img/image-20210812090013283.png)] 创建步骤（创建进程首先要将
重读金典------高质量C编程指南（林锐）-------第七章 内存管理
weixin_33755649的博客
03-19 97
2015/12/10补充： 当我们需要给一个数组返回所赋的值的时候，我们需要传入指针的指针。当我们只需要一个值的时候，传入指针即可，或者引用也可以。 结构大致如下： char* p = (char*)malloc(sizeof(char)*num); while() { func(char** p); } free(p); void func(char**p)...
内存管理
liqingbing12的专栏
07-14 260
内存碎片问题 应用程序频繁地请求和释放不同大小的内存，必然导致内存碎片问题的产生，结果就是当再次要求分配连续的内存时，即使整体内存是足够的，也无法满足连续内存的需求，该问题也称之为外碎片(external fragmentation)。 避免外碎片的方法 方案一：使用地址转换技术，把非连续的物理地址转换成连续的线性地址。 方案二：开发一种适当的技术来记录现存的空闲的连续页框块的情况，以尽量避免为满足对小块的请求而分割大的空闲块。即开发一种特有的分配技术来记录下来空闲内存的情况， Linux采用了第二
详细介绍一下内存管理子系统
03-28
内存管理子系统是操作系统中的重要组成部分，主要负责管理计算机中的物理内存和虚拟内存。内存管理子系统的工作包括内存分配、内存回收、内存保护、内存映射和虚拟内存管理等。 内存分配是内存管理子系统最基本的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

捕获一只小肚皮

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值