xf.cpp

里面是有关C++的程序

#include"stdio.h"
#include<iostream.h>
#include<string.h>
#include <stdlib.h>
#include <time.h>
#define n 10 //模拟实验中允许的最大进程数为n
#define m 10 //模拟实验中允许的最大分区个数为m
#define M_SIZE 10000 

struct 
{	
float address; //分配给进程的起始地址
float length; //分配给进程的空闲区长度，单位为字节
int flag;    //分配区表标志，用"0"已分配，用"1"表示未分配
}Used_Table[m]; //分配分区表


struct 
{ 
float address; //空闲区起始地址
float length; //空闲区长度，单位为字节 
int flag;    //空闲区表登记栏标志，用"0"表示已分配，用"1"表示未分配
}Free_table[m]; //空闲分区表

float stand_length(int k)//随机产生一个分区大小的函数
{
float  st_length[20];
srand((unsigned)time(NULL));//srand()函数产生一个当前时间开始的随机种子
for (int i=0;i<20;i++)
st_length[i]=float (rand()%1000);
return st_length[k];
}


float process_length(int k)//随机产生一个进程大小的函数
{
float  pt_length[20];
srand((unsigned)time(NULL));//srand()函数产生一个当前时间开始的随机种子
for (int i=0;i<20;i++)
pt_length[i]= float (rand()%500);
return pt_length[k];
}



int process_num()//随机产生一个进程个数的函数
{
int num;
int A[10]={1,2,3,4,5,6,7,8,9,10};
srand((unsigned)time(NULL));
num=rand()%10;
return A[num];
}

char srand_name(int k)//随机产生一个进程的名字
{

char A[26]={'A','B','C','D','E','F','G','H','I',
  'J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
  return A[k];

}

void allocate(char PRS_NAME,float X_K) //采用最优分配算法为进程PRS_NAME分配X_K大小的空间
{ 
int i,k; 
float ad; 
k=-1; 
for(i=0;i<m;i++) //寻找空间大于X_K的最小空闲区登记项k
if(Free_table[i].length>=X_K&&Free_table[i].flag==1) 
if(k==-1||Free_table[i].length<Free_table[k].length) 
k=i; 
if(k==-1)//未找到可用空闲分区，返回
{ 
printf("无可用空闲区\n"); 
return; 
} 
//找到可用空闲区，开始分配：
//若空闲区大小与要求分配的空间差小于M_SIZE大小，则空闲区全部分配；
//若空闲区大小与要求分配的空间差大于M_SIZE大小，则从空闲区划出一部分分配
if(Free_table[k].length-X_K<=M_SIZE) 
{ 
Free_table[k].flag=0; 
ad=Free_table[k].address; 
X_K=Free_table[k].length; 
} 
else 
{ 
Free_table[k].length=Free_table[k].length-X_K; 
ad=Free_table[k].address+Free_table[k].length; 
} 
//修改已分配区表
i=0; 
while(Used_Table[i].flag!=0&&i<n) //寻找空表目
i++; 
if(i>=n) //无表目填写已分分区
{ 
printf("无表目填写已分分区，错误\n"); 
//修正空闲区表 
if(Free_table[k].flag==0) 
//前面找到的是整个空闲分区  
Free_table[k].flag=1; 
else 
{//前面找到的是某个空闲分区的一部分  
Free_table[k].length=Free_table[k].length+X_K; 
return; 
} 
} 
else 
{//修改已分配表 
Used_Table[i].address=ad; 
Used_Table[i].length=X_K; 
Used_Table[i].flag=PRS_NAME; 
} 
return; 
}//内存分配函数结束 

void reclaim(char PRS_NAME) //回收进程名为PRS_NAME的进程所占内存空间 
{ 
int i,k,j,s,t; 
float S,L; 
//寻找已分配表中对应登记项 
s=0; 
while((Used_Table[s].flag!=PRS_NAME||Used_Table[s].flag==0)&&s<n) 
s++; 
if(s>=n)//在已分配表中找不到名字为PRS_NAME的进程
{ 
printf("找不到该进程\n"); 
return; 
} 
//修改已分配表
Used_Table[s].flag=0; //取得归还分区的起始地址S和长度L
S=Used_Table[s].address; 
L=Used_Table[s].length; 
j=-1;k=-1;i=0; 
//寻找回收分区的空闲上下邻，上邻表目k，下邻表目j
while(i<m&&(j==-1||k==-1)) 
{ 
if(Free_table[i].flag==1) 
{ 
if(Free_table[i].address+Free_table[i].length==S)k=i;//找到上邻
if(Free_table[i].address==S+L)j=i;//找到下邻
} 
i++; 
} 
if(k!=-1) 
if(j!=-1) 
// 上邻空闲区，下邻空闲区，三项合并
{ 
Free_table[k].length=Free_table[j].length+Free_table[k].length+L; 
Free_table[j].flag=1; 
} 
else 
//上邻空闲区，下邻非空闲区，与上邻合并
Free_table[k].length=Free_table[k].length+L; 
else 
if(j!=-1) 
//上邻非空闲区，下邻为空闲区，与下邻合并
{ 
Free_table[j].address=S; 
Free_table[j].length=Free_table[j].length+L; 
} 
else //上下邻均为非空闲区，回收区域直接填入
{ 
//在空闲区表中寻找空栏目 
t=0; 
while(Free_table[t].flag==1&&t<m) 
t++; 
if(t>=m)//空闲区表满,回收空间失败,将已分配表复原
{ 
cout<<"内存空闲表没有空间,回收空间失败"<<endl; 
Used_Table[s].flag=j; 
return; 
} 
Free_table[t].address=S; 
Free_table[t].length=L; 
Free_table[t].flag=1; 
} 
return; 
}


//主函数
void main( ) 
{ 
int i,a; 
float p_length; 
char p_name; 
//空闲分区表初始化：
int t_P;
Free_table[0].address=10000;
for(t_P=0; t_P<m; t_P++)
{
Free_table[t_P].length=stand_length(t_P); 
Free_table[t_P].flag=1; 
}

for(t_P=1;t_P<m;t_P++)
{
Free_table[t_P].address=Free_table[t_P-1].address+Free_table[t_P-1].length;
}//空闲分区表初始化结束
//已分配表初始化：
for(i=0;i<n;i++) 
Used_Table[i].flag=0; 
cout<<"--------------模拟固定分区存储管理的分配与回收------------"<<endl<<endl;
cout<<"*********************功能选项*****************************"<<endl;
cout<<"*     0——退出               1——随机产生进程并分配内存*"<<endl;
cout<<"*     2——回收进程和内存     3——显示内存分配记录      *"<<endl;
cout<<"**********************************************************"<<endl;
while(1) 
{ 

cout<<"输入选择的功能项(0--3) :"<<endl;
cin>>a;
switch(a) 
{ 
case 0: return;///a=0选择退出程序结束 
case 1: //选择a=1，开始随机的产生进程并分配空间
	{
int p_num=process_num();
cout<<"随机产生"<<p_num<<"个进程"<<endl;
int p_p;
cout<<"进程名    进程大小"<<endl;
for(p_p=0;p_p<p_num;p_p++)
{
p_name=srand_name(p_p);
p_length= process_length(p_p);
cout<<p_name<<"           "<<p_length<<endl;
allocate(p_name,p_length);//分配内存空间 
}
cout<<"要查看内存分配请在提示命令出现后输入'3'回车"<<endl;
	}
break; 
case 2: //a=2回收内存空间 
cout<<"输入要回收分区的进程名"; 
cin>>p_name; 
reclaim(p_name);//回收内存空间 
break; 
case 3: //a=3显示内存情况
//输出空闲分区表和已分配分区表的内容
cout<<"输出空闲区表："<<endl;
cout<<"------------------------------------------------------"<<endl;
cout<<"起始地址 分区大小 标志(0—已分配，1—未分配)"<<endl; 
for(i=0;i<m;i++) 
printf("%6.0f%9.0f%6d\n",Free_table[i].address,Free_table[i].length, Free_table[i].flag); 
cout<<"已分配分区表："<<endl;
cout<<"------------------------------------------------------"<<endl;
cout<<"起始地址 分区大小 进程名"<<endl;
for(i=0;i<n;i++) 
if(Used_Table[i].flag!=0) 
printf("%6.0f%9.0f%6c\n",Used_Table[i].address,Used_Table[i].length, Used_Table[i].flag); 
break; 
default:
cout<<"没有该选项，请输入正确的选项！"<<endl; 
}
}
}