c++_动态分配分区算法

最新推荐文章于 2024-05-06 20:29:07 发布
最新推荐文章于 2024-05-06 20:29:07 发布
阅读量2.2k 收藏 10
点赞数 1
文章标签： c++ ini 算法 input include
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mrwuhuai/article/details/7029564
版权
 

#include <iostream>
using namespace std;
const int MaxNumber=100;
int  FreePartition[MaxNumber];

int  ProcessNeed[MaxNumber];
int  n,m;
int  i,j,k,x,y,z;
int  b[MaxNumber];
int  p[MaxNumber];
int  q[MaxNumber];
int  r[MaxNumber];
int  t[MaxNumber];
char a[MaxNumber][3];
char w;
//char Partition[MaxNumber];
char Process[MaxNumber];
void input(){
 cout<<"=========================="<<endl;
 cout<<"=====动态分区分配算法====="<<endl;
 cout<<"**************************"<<endl;
 cout<<"请输入内存中空闲分区个数为n：";
 cin>>n;
 cout<<endl;
 cout<<"请输入需要分配的进程个数为m(必须满足：n>=m)：";
 cin>>m;
 cout<<endl;
 
 cout<<"请输入空闲分区大小,单位(k)："<<endl;
 for(i=0;i<n;i++){
  cin>>FreePartition[i];
 }

 cout<<"请输入进程名："<<endl;
 for(i=0;i<m;i++){
  cin>>Process[i];
 }
 cout<<"输入各个进程需要空间大小,单位(k):"<<endl;
 for(i=0;i<m;i++){
  cin>>ProcessNeed[i];
 }
}
void First(){
 cout<<endl;
 cout<<"首次适应算法（First）："<<endl;
 for(i=0;i<n;i++){
  p[i]=FreePartition[i];
  
 }
 for(i=0;i<n;i++)
  for(j=0;j<3;j++){
   a[i][j]='*';
  }

 for(i=0;i<m;i++)
  for(j=0;j<n;j++){
   if(ProcessNeed[i]<=p[j]){
    
    p[j]-=ProcessNeed[i];
   
    if(a[j][0]!='*'){

     if(a[j][1]!='*')
      a[j][2]=Process[i];
     else
        a[j][1]=Process[i];
    }
    else
    {
     a[j][0]=Process[i];
    }
    break;

   }
  }
  cout<<endl;
  for(i=0;i<n;i++){
   for(j=0;j<3;j++){

    cout<<a[i][j];
   }
   cout<<"  ||";
  }
  cout<<endl;

}
void Circle(){
  cout<<endl;
 cout<<"循环首次算法（Circle）："<<endl;
 for(i=0;i<n;i++){
  p[i]=FreePartition[i];
 
  
 }
 for(i=0;i<n;i++)
  for(j=0;j<3;j++){
   a[i][j]='*';
  }
    j=0;
 for(i=0;i<m;i++)
  for(;j<n;j++){
   if(ProcessNeed[i]<=p[j]){
    
    p[j]-=ProcessNeed[i];
   
    if(a[j][0]!='*'){

     if(a[j][1]!='*')
      a[j][2]=Process[i];
     else
        a[j][1]=Process[i];
    }
    else
    {
     a[j][0]=Process[i];
    }
    break;

   }
  }
  cout<<endl;
  for(i=0;i<n;i++){
   for(j=0;j<3;j++){

    cout<<a[i][j];
   }
   cout<<"  ||";
  }

cout<<endl;


}

void Best(){
 cout<<endl;
 cout<<"最佳适应算法（Best）："<<endl;
 for(i=0;i<n;i++){
  p[i]=FreePartition[i];
  r[i]=0;
  
 }
 for(i=0;i<n;i++)
  for(j=0;j<3;j++){
   a[i][j]='*';
  }

 for(i=0;i<m;i++){
   for(k=0;k<n;k++){
    if(r[k]!=2){
    
     r[k]=0;
    }
   }
  
   

   for(j=0;j<n;j++){
    if(ProcessNeed[i]<=p[j]){
     p[j]-=ProcessNeed[i];
     r[j]=1;
    }
   }
   for(k=0;k<n;k++){
    q[k]=p[k];
   }
   
   for(k=0;k<n;k++)
   { 
    if(r[k]==1){
        x=q[k];
    }
   }
   for(k=0;k<n;k++)
   { 
    if(r[k]==1){
        if(x>q[k])
     {
         x=q[k];
        
     }
    }
   }

      for(k=0;k<n;k++){
     if(p[k]==x)
    {
      if(a[k][0]!='*'){

     if(a[k][1]!='*')
      a[k][2]=Process[i];
     else
        a[k][1]=Process[i];
      }
       else
     {
        a[k][0]=Process[i];
     }
   
    y=k;
    r[k]=2;
    break;
     }
   }
  
   for(k=0;k<n;k++){
     if(k!=y&&r[k]!=2){
      p[k]=FreePartition[k];
      
     }
    
     
    }
  }


 cout<<endl;
  for(i=0;i<n;i++){
   for(j=0;j<3;j++){

    cout<<a[i][j];
   }
   cout<<"  ||";
  }

cout<<endl;
    


}
void Worst(){
  cout<<endl;
 cout<<endl;
 cout<<"最坏适应算法（Worst）："<<endl;
 for(i=0;i<n;i++){
  p[i]=FreePartition[i];
   b[i]=FreePartition[i];
  r[i]=0;
  t[i]=0;
  
 }

 for(i=0;i<n;i++)
  for(j=0;j<3;j++){
   a[i][j]='*';
  }
 
 for(i=0;i<m;i++){
   for(k=0;k<n;k++){
    if(t[k]!=2){
    
     r[k]=0;
    }
   
   }
 
   for(j=0;j<n;j++){
    b[j]=p[j];
   
   }
 

   for(j=0;j<n;j++){
    if(ProcessNeed[i]<=p[j]){
     p[j]-=ProcessNeed[i];
     r[j]=1;
    }
   }
   for(k=0;k<n;k++){
    q[k]=p[k];
   }
   
   for(k=0;k<n;k++)
   { 
    if(r[k]==1){
        x=q[k];
    }
   }
   for(k=0;k<n;k++)
   { 
    if(r[k]==1){
        if(x<q[k])
     {
         x=q[k];
        
     }
    }
   }
          
      for(k=0;k<n;k++){

     if(p[k]==x)
     { 
      for(j=0;j<n;j++){
         p[j]=b[j];
    
      }
   
      p[k]-=ProcessNeed[i];

      if(a[k][0]!='*'){

     if(a[k][1]!='*')
      a[k][2]=Process[i];
     else
        a[k][1]=Process[i];
      }
       else
     {
        a[k][0]=Process[i];
     }
    r[k]=2;
     
    y=k;
   
   
    t[k]=2;
    break;
     }
   }
  
 
  }


 cout<<endl;
  for(i=0;i<n;i++){
   for(j=0;j<3;j++){

    cout<<a[i][j];
   }
   cout<<"  ||";
  }

cout<<endl;
    


}
void main(){
 input();
 cout<<"============================="<<endl;

 cout<<endl;
 cout<<"输入1_首次适应算法。"<<"输入2_循环首次算法。"<<endl;
 cout<<"输入3_最佳适应算法。"<<"输入4_最坏适应算法。"<<endl;
 cout<<"输入5_所有都打印出来。"<<"输入0退出系统！"<<endl;
 cout<<"请输入：";
 cin>>w;
 while(w!='0')
 {
  switch(w){
  case '1':
    for(i=0;i<n;i++){
 
  cout<<"第"<<i<<"区"<<"||";
 }
  cout<<endl;
 for(i=0;i<n;i++){
 
  cout<<"  "<<FreePartition[i]<<"   ";
 }
   First();
   break;
  case'2':
    for(i=0;i<n;i++){
 
  cout<<"第"<<i<<"区"<<"||";
 }
  cout<<endl;
 for(i=0;i<n;i++){
 
  cout<<"  "<<FreePartition[i]<<"   ";
 }
   Circle();
   break;
  case'3':
    for(i=0;i<n;i++){
 
  cout<<"第"<<i<<"区"<<"||";
 }
  cout<<endl;
 for(i=0;i<n;i++){
 
  cout<<"  "<<FreePartition[i]<<"   ";
 }
   Best();
   break;
  case'4':
    for(i=0;i<n;i++){
 
  cout<<"第"<<i<<"区"<<"||";
 }
  cout<<endl;
 for(i=0;i<n;i++){
 
  cout<<"  "<<FreePartition[i]<<"   ";
 }
   Worst();
   break;
  case'5':
    for(i=0;i<n;i++){
 
  cout<<"第"<<i<<"区"<<"||";
 }
  cout<<endl;
 for(i=0;i<n;i++){
 
  cout<<"  "<<FreePartition[i]<<"   ";
 }
   First();
         Circle();
         Best();
         Worst();
   break;
  }
  cout<<endl;
   cout<<"输入1_首次适应算法。"<<"输入2_循环首次算法。"<<endl;
 cout<<"输入3_最佳适应算法。"<<"输入4_最坏适应算法。"<<endl;
 cout<<"输入5_所有都打印出来。"<<"输入0退出系统！"<<endl;
 cout<<"请输入：";
 cin>>w;


  }
 


}

Mrwuhuai
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
操作系统简单动态分区分配算法(c++)
凛_Lin~~的博客
01-09 2351
操作系统基本动态内存分配算法,首次适应和最佳适应
操作系统动态分区分配方式C/C++语言（首次适应算法（FF）循环首次适应算法（NF）最best适应算法（BF）最坏适应算法（WF））
weixin_48560325的博客
12-06 1万+
算法介绍 一、动态分区分配算法 为把一个新作业装入内存，须按照一定的分配算法， 从空闲分区表或空闲分区链中出一分区分配给该作业。由于内存分配算法对系统性能有很大的影响，故人们对它进行了较为广泛而深入的研究，于是产生了许多动态分区分配算法。传统的四种分配算法，它们都属于顺序式搜索算法。 二、分区分配操作 在动态分区存储管理方式中，主要的操作是分配内存和回收内存。 1)分配内存 系统应利用某种分配算法，从空闲分区链(表)中找到所需大小的分区。设请求的分区大小为u.size,表中每个空闲分区的大小可表示为m.si
动态分区分配（C++实现）
mycocoo的博客
12-09 3452
#include <iostream> using namespace std; const int MaxNumber = 100; int FreePartition[MaxNumber];//空闲可用分区 int Partition[MaxNumber];//进程所需分区 int PartitionNum, ProcessNum; int n; //空闲分区个数 int m;//需要分配的进程个数 //首次适应算法 void FF() { //寻找大小能满足进程要求的分区 for (
操作系统——动态内存分配C++实现
小唐要努力的博客
06-27 5187
动态内存分配问题是现代操作系统必须要考虑的一个核心问题，老师最近要求我们用C语言实现一下书上的两种方法，首次适应算法和最佳适应算法，因为C语言的输入输出实在有些麻烦我就偷懒用了一下C++的输入输出和new函数，整体还是C语言（虽然不用类封装的话两者好像没啥大却别），那么先简短介绍一下两个算法的思路。 首次适应算法是当有作业申请内存时，将作业放置在主存中第一个足够装入它的可利用的空闲去...
动态分区分配算法
热门推荐
cm_cyj_1116的博客
12-08 3万+
动态分区分配算法 一.顺序搜索的动态分区分配算法 1.首次适应算法（First Fit）  算法思想：将空闲分区链以地址递增的顺序连接；在进行内存分配时，从链首开始顺序查找，直到找到一块分区的大小可以满足需求时，按照该作业的大小，从该分区中分配出内存，将剩下的空闲分区仍然链在空闲分区链中。 优点：高址部分的大的空闲分区得到保留，为大作业的内存分配创造了条件； 缺点：（1）每次都是
操作系统——实验五 动态分区分配算法的模拟
08-05
用C/C++实现一个完整的（可变）动态分区管理器，包括分配，回收，分区碎片整理等。希望同学们实现如下功能： 初始化功能：内存状态设置为初始状态。 分配功能：要求至少使用两种算法，用户可以选择使用。 回收...
OS课程设计_动态分区分配算法
07-27
操作系统的动态分区分配算法（控制台程序），供学习使用。
动态分配分区算法
02-15
操作系统课上写的动态分配分区算法的实验报告，尽可能的做了详细的注释，仅用于学习交流
计算机操作系统实验_动态分区分配方式模拟
12-01
1、代码完整，注释很详细，复制到... 测试用例格式如下： 输入： 动态分区分配算法选择 可用内存空间容量 序号/进程号/申请或释放操作/申请或释放的容量 其中： (1 ) 动态分区分配算法：1----首次适应，2----最佳适应。
操作系统实习：动态分区分配（C++实现）
11-26
操作系统实习：动态分区分配（C++实现）包含源程序和运行结果
动态分区内存分配模拟C++
11-06
类MemMgr（表示Memory Manager）有一个virtual int searchAlgo( int size )= 0; 这是一个纯虚的函数， MemMgr的两个子类FirstAdapter(首次适应算法)，OptiAdapter(最佳适应算法)分别实现了那个纯虚函数， 表示了当有size大小的内存分配需求时， 所采取的不同分配算法， 如果还有其他的分配算法， 就只需要继承MemMgr， override virtual int searchAlgo( int size )这个函数即可。
操作系统--动态分配存储空间
05-26
c++描述的分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc()和回收过程free()。其中，空闲分区通过空闲分区链来管理；在进行内存分配时，系统优先使用空闲区低端的空间。
基于C语言的动态分区分配算法实现
毕业作品网站
02-10 611
上一层是分配分区的函数 alloc()和回收分区的函数 free()。在实际的操作系统中，分配出去的内存记录在进程控制块中，为了加快内存的分配过程，动态分区最常采用的数据结构是空闲表或空闲链表，数据结构只记录未分配的内存分区。为了降低模拟程序的复杂度，本模拟将分配出去的和未分配出去的内存分区记录在同一个数据结构中，用一个标志表示是否已被分配。为使程序具有扩展性灵活性， 分区大小采用宏定义方式（ #define MEMORY_SIZE 640），可修改分区的大小，展示在不同分区大小下的分配情况。
动态分区分配算法(First Fit，Next Fit，Best Fit，Worst Fit)
木牛的博客
06-15 9743
1.首次适应算法（First Fit）2.循环首次适应算法（Next Fit）3.最佳适应算法（Best Fit）4.最坏适应算法（Worst Fit）1.首次适应算法（First Fit）2.循环首次适应算法（Next Fit） 3.最佳适应算法（Best Fit） 4.最坏适应算法（Worst Fit） 1.首次适应算法（First Fit）2.循环首次适应算法（Next Fit）3.最佳适应算法（Best Fit）4.最坏适应算法（Worst Fit） (488条消息) 动态分
首次适应算法 动态分区分配方式的模拟 C语言——课程设计实习
m0_46404001的博客
01-07 7128
用C语言实现采用首次适应算法的动态分区分配过程alloc()和回收过程free()。其中，空闲分区通过空闲分区链表来管理，在进行内存分配时，系统优先使用空闲区低端的空间 - 假设初始状态如下，可用的内存空间为640KB，并有下列的请求序列；采用首次适应算法进行内存块的分配和回收，同时显示内存块分配和回收后空闲内存分区链的情况 - 假设初始状态如下，可用的内存空间为640KB，并有下列的请求序列； 作业1申请130KB 作业2申请60KB 作业3申请100KB 作业2释放60KB 作业4申请200 KB
C语言操作系统实战:动态分区分配方式
qq_62169881的博客
07-25 697
空闲分区以地址递增的顺序（这里并不是地址空间的大小）的次序排列。由于匹配的地址空间大小为第一个满足要求的地址空间，这就会导致大的地址空间被小进程占据，使得大进程到来时没有满足要求的地址空间，发生系统中断。空闲分区按地址空间大小递增次序排列，每次分配时按顺序查找相关满足要求的地址空间即可。由于每次匹配的尽可能小的且满足地址空间要求的，就会导致地址空间可能会被切割成很多过小的地址空间碎片而无法被利用。请分别采用首次适应算法和最佳适应算法进行内存块的分配和回收，要求每次分配和回收后显示出空闲分区链的情况。
高性能内存分配器 jemalloc 基本原理
悟已往之不谏，知来者之可追
11-30 1507
文章目录背景知识常用内存分配器算法动态内存分配伙伴算法Slab 算法jemalloc 架构设计 在上一篇文章中，我们介绍了强大的 ByteBuf 工具类，ByteBuf 在 Netty 中随处可见，那么这些 ByteBuf 在 Netty 中是如何被分配和管理的呢？接下来的我们会对 Netty 高性能内存管理进行剖析，这些知识相比前面的章节有些晦涩难懂，你不必过于担心，Netty 内存管理的实现并不是一蹴而就的，它也是参考了 jemalloc 内存分配器。今天我们就先介绍 jemalloc 内存分配器的基本
C++（引用）
最新发布
weixin_61218382的博客
05-06 307
给变量其别名数据类型 &别名 = 原名。
动态分区分配算法c++
06-07
动态分区分配算法是一种内存管理技术，它将系统内存分成若干个大小不等的分区，每个分区可以被分配给进程使用。常见的动态分区分配算法有首次适应算法、最佳适应算法和最坏适应算法。 以下是一个简单的C++程序，实现了首次适应算法的动态分区分配： ```c++ #include <iostream> #include <cstring> using namespace std; const int MAX_SIZE = 100; // 内存大小 int memory[MAX_SIZE]; // 内存数组 int size[MAX_SIZE]; // 内存块大小数组 // 初始化内存 void init() { memset(memory, 0, sizeof(memory)); memset(size, 0, sizeof(size)); } // 首次适应算法 int firstFit(int req_size) { for (int i = 0; i < MAX_SIZE; i++) { if (size[i] >= req_size && memory[i] == 0) { // 找到合适的内存块 int j; for (j = i; j < MAX_SIZE; j++) { if (memory[j] != 0) { break; } } // 分配内存 for (int k = i; k < j; k++) { memory[k] = 1; } size[i] -= req_size; return i; } } return -1; // 没有找到合适的内存块 } int main() { init(); // 初始化内存 int req_size = 10; // 请求分配内存大小 int index = firstFit(req_size); // 调用首次适应算法 if (index != -1) { cout << "分配内存成功，起始地址为：" << index << endl; } else { cout << "分配内存失败！" << endl; } return 0; } ``` 在这个程序中，我们使用了一个大小为100的内存数组和一个大小为100的内存块大小数组，其中内存数组的每个元素表示一个内存块是否被占用（0表示未被占用，1表示被占用），内存块大小数组的每个元素表示对应内存块的大小。首次适应算法的实现是通过遍历内存块大小数组，找到第一个大小大于等于请求分配内存大小的空闲内存块，然后从该空闲内存块开始向后查找连续的空闲内存块，并将它们标记为已占用状态，最后返回该内存块的起始地址。如果没有找到合适的内存块，则返回-1表示分配内存失败。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值