这个实验是很多个小的实验所组成的，现在看我两年前留下的资料，我还留着其中的四个。分别是
处理机调度：设计一个按时间片轮转法实现进程调度的程序
银行家算法：
主存储器空间的分配和回收：在可变分区管理方式下实现主存分配和实现主存回收（最先适应算法）
独占设备的分配和回收：临界资源
文件系统：这个我也不知道咋就没了，但是上边四个可以让你得一个良肯定没问题。
代码有祖传的有我自己写的，但是我应该都写了注释，读起来是不难的。
第一个
#include<iostream>
#include<string>
#include<iomanip>
#include<algorithm>
#define N 5
using namespace std;
struct process
{
int PS; //进程序号
int RunTime; //估计运行时间
char State = 'R'; //运行状态
int ArrTime;//进程的到达时间
process* next;//进程指向的下一个进程
process(int PS, int RunTime, int ArrTime, process* next = NULL)
{
this->PS = PS;
this->RunTime = RunTime;
this->State = 'R';
this->ArrTime = ArrTime;
this->next = next;
}
};
//打印出当前各个进程的运行情况
void PrintProcess(process * p)
{
for (int i = 0; i < 5; i++)
{
cout << "进程编号" << " " << "剩余运行时间" << " " << "目前状态" << endl;
cout << " " << i << " " << p->RunTime << " " << p->State << endl;
p = p->next;
}
}
//遍历一遍链表，到达就执行，不到达就跳过
void CheckOnce(process * p, int& Timer)
{
for (int i = 0; i < 5; i++)
{
if (p->ArrTime > Timer)
{
//这个程序还没到达，先跳过，直接到下一个进程,假设这个判断不消耗时间片
p = p->next;
continue;
}
else
{
if (p->RunTime == 0)
{
p->State = 'C';
}
else if (p->RunTime != 0)
{
//运行一个时间片
p->RunTime -= 1;
if (p->RunTime == 0)
{
p->State = 'C';
}
cout << "Process[" << p->PS << "] is Running now." << endl;
Timer++;
}
}
p = p->next;
}
cout << endl;
PrintProcess(p);//打印目前各个进程的状态
cout << endl << endl << endl;
}
//判断所有进程是不是都执行完毕了
bool IsFinished(process * p)
{
int count = 0;
for (int i = 0; i < 5; i++)
{
if (p->RunTime != 0)
{
count++;
}
p = p->next;
}
if (count == 0)
{
return true;
}
return false;
}
//进行时间片轮转的函数
void RoundTime(process * p)
{
int Timer = 0;
while (!IsFinished(p))
{
CheckOnce(p, Timer);
}
cout << "All processes have finished !" << endl;
}
//主函数
int main()
{
process p4 = { 4,1,9,NULL };
process p3 = { 3,2,3,NULL };
process p2 = { 2,4,2,NULL };
process p1 = { 1,3,1,NULL };
process p0 = { 0,9,0,NULL };
p0.next = &p1;
p1.next = &p2;
p2.next = &p3;
p3.next = &p4;
p4.next = &p0;
//cout << "Enter the Process Running time in order of their arrive time" << endl;
//cin >> p0.RunTime >> p1.RunTime >> p2.RunTime >> p3.RunTime >> p4.RunTime;
//cout << p0.next->RunTime << endl;
// cout << p0.RunTime << endl;
RoundTime(&p0);
return 0;
}第二个
#include<iostream>
#include<string>
#include<iomanip>
#include<algorithm>
using namespace std;
int Max[100][100] = { 0 }; //各进程对资源的最大需求数
int Allocation[100][100] = { 0 }; //已经给各进程分配了多少资源
int Need[100][100] = { 0 }; //各进程还需要多少资源
int Available[100] = { 0 }; //总的可用资源
int Request[100] = { 0 }; //进程此次申请的各种资源数
int Afford[100] = { 0 }; //还有多少可用资源，同Avaliable
int Security[100] = { 0 }; //安全序列的进程
char Name[100] = { 0 }; //各类资源名称
int M, N; //进程数和资源种类
void init() {
cout << "请输入可分配的资源种类数量:";
cin >> N;
cout << endl;
for (int i = 0; i < N; i++) {
cout << "请输入第" << i + 1 << "个资源的名称:";
cin >> Name[i];
cout << "请输入" << Name[i] << "资源的可分配数量:";
cin >> Available[i];
cout << endl;
}
cout << endl << "请输入进程数量:";
cin >> M;
cout << endl << "请输入进程的Max矩阵" << endl;
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
cin >> Max[i][j]; //输入每个进程所需要的各种资源的最大数量
}
}
cout << endl << "请输入进程的Allocation矩阵" << endl;
int every[100] = { 0 };
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
cin >> Allocation[i][j]; //每个进程已经分配的各种资源的数量
Need[i][j] = Max[i][j] - Allocation[i][j]; //Need数组通过最大-已经获得
every[j] += Allocation[i][j]; //统计每一种类已经分配的资源数量
}
}
for (int j = 0; j < N; j++) {
Available[j] = Available[j] - every[j]; //总的-已经分配处去的=现在剩余的可分配数量
}
}
void show_info() {
cout << endl << endl;
//cout << " " << "****************" << endl;
//cout << " " << "系统当前可用的资源矩阵Available:" << endl;
//cout << " " << "****************" << endl;
//cout << " ";
int i;
for (i = 0; i < N; i++)
cout << " " << Name[i];
cout << endl << " ";
for (i = 0; i < N; i++)
cout << " " << Available[i];
cout << endl << endl;
//cout << " " << "****************" << endl;
//cout << " " << "系统当前资源分配情况如下:" << endl;
//cout << " " << "****************" << endl << endl;
cout << " " << " Max Allocation Need " << endl;
//cout << "进程名 ";
for (int i = 0; i < 3; i++) { //资源名称需要打印三次，分别对应max、allocation、need数组
for (int j = 0; j < N; j++) { //打印所有的资源名称
cout << Name[j] << " ";
}
}
cout << endl;
for (int i = 0; i < M; i++) { //打印进程每个进程的三种矩阵
cout << " Pro" << i;
for (int j = 0; j < N; j++) {
cout << " " << Max[i][j];
}
for (int j = 0; j < N; j++) {
cout << " " << Allocation[i][j];
}
for (int j = 0; j < N; j++) {
cout << " " << Need[i][j];
}
cout << endl;
}
}
//安全性检查!
bool is_Safe() {
int isAfford[100] = { 0 }; //是否有足够的资源分配给进程
for (int i = 0; i < N; i++) {
Afford[i] = Available[i]; //在执行安全算法开始时，Work=Available
}
int count = 0, m = 0; //count是用来统计系统足够某个进程所需要的某种资源数量
for (int i = 0; i < M; i++) {
count = 0;
for (int j = 0; j < N; j++) {
if (isAfford[i] == 0 && Need[i][j] <= Afford[j]) { //如果进程没有执行且资源需求条件满足
count++; //这种资源是够的
if (count == N) { //表示对于i号进程所有资源都满足
isAfford[i] = 1; //记录i号进程为可执行
for (int k = 0; k < N; k++) {
Afford[k] = Afford[k] + Allocation[i][k]; //进程执行成功，回收各资源
}
Security[m++] = i; //此进程可以进入安全序列
i = -1; //将i置为-1;通过for循环执行i++后变为0，从第一个进程重新开始找
}
}
}
}
for (int i = 0; i < M; i++) { //依次检查各进程，如果有一个不满足，就说明不安全
if (isAfford[i] == 0) {
cout << endl << "系统不安全" << endl;
return false;
}
}
cout << endl << "系统安全" << endl << endl;
cout << "安全序列:";
for (int i = 0; i < M; i++) {
cout << "P" << Security[i];
if (i < M - 1)
cout << "-->";
}
cout << endl << endl;
return true;
}
bool bank() {
cout << "请输入手动分配资源的进程编号:";
int id;
bool flag = true;
while (cin >> id) {
if (id < 0 || id > M - 1) {
cout << endl << "进程不存在!请重新输入!" << endl;
cout << endl << "请重新输入希望手动分配资源的进程的编号:";
}
else break;
}
cout << endl << "请分别输入各类请求资源数(" << N << "个):";
for (int i = 0; i < N; i++) {
cin >> Request[i];
}
cout << endl << "开始为进程Pro" << id << "分配资源,请等待..." << endl;
for (int i = 0; i < N; i++) {
if (Request[i] > Need[id][i]) {
cout << "进程请求资源数大于所需资源数，无法分配!" << endl;
flag = false;
break;
}
else if (Request[i] > Available[i]) {
cout << "进程请求资源数大于可用资源数，无法分配!" << endl;
flag = false;
break;
}
else {
Available[i] -= Request[i]; //可用资源数减少
Allocation[id][i] += Request[i]; //已分配资源数增加
Need[id][i] -= Request[i]; //所需资源数减少
}
}
if (flag == true) {
if (is_Safe())
cout << "分配资源完成!" << endl;
else {
for (int i = 0; i < N; i++) {
Available[i] += Request[i]; //分配资源回收
Allocation[id][i] -= Request[i];
Need[id][i] += Request[i];
}
cout << endl << "此次分配会导致系统不安全，无法分配!" << endl;
}
}
return flag;
}
int main() {
//cout << " " << "****************" << endl;
//cout << " " << "银行家算法" << endl;
//cout << " " << "****************" << endl << endl;
init();
show_info();
is_Safe();
//cout << " " << "****************" << endl;
//cout << " " << "手动进行资源请求" << endl;
//cout << " " << "输入R/r请求资源" << endl;
//cout << " " << "输入E/e退出程序" << endl;
//cout << " " << "****************" << endl;
char choice;
while (true) {
//cout << endl << "请选择资源分配(R/r)还是退出(E/e):";
cin >> choice;
cout << endl;
if (choice == 'R' || choice == 'r') {
if (bank()) { //可分配
show_info(); //展示信息
} //这边由于上述bank()算法已经进行了安全性检查，此处无需再次调用
else {
show_info();
}
}
else if (choice == 'E' || choice == 'e') {
cout << "退出程序成功!" << endl;
exit(0);
}
else
printf("请正确选择!");
}
return 0;
}
/*
3
10 5 7
7 5 3
3 2 2
9 0 3
2 2 2
4 3 3
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
*/第三个
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <iomanip>
#define n 100 // 最大空闲区个数
using namespace std;
int p_num = 4; // 作业个数
int num = 2; // 空闲区个数
struct
{
char name[20];
int address;
int length; int flag;
} free_table[n], work_table[n], temp;
void sort() // 空闲区按起始地址从小到大排序
{
int i;
for (i = 0; i < num - 1; i++)
for (int j = 0; j < num - i - 1; j++)
if (free_table[j].address > free_table[j + 1].address)
{
temp = free_table[j];
free_table[j] = free_table[j + 1];
free_table[j + 1] = temp;
}
for (i = 0; i < p_num - 1; i++)
for (int j = 0; j < p_num - i - 1; j++)
if (work_table[j].address > work_table[j + 1].address)
{
temp = work_table[j];
work_table[j] = work_table[j + 1];
work_table[j + 1] = temp;
}
}
void merge() // 扫描空闲区若前后有相邻空闲区则合并
{
for (int i = 0; i < num - 1; i++)
{
if (free_table[i].address + free_table[i].length == free_table[i + 1].address)
{
if (!free_table[i].flag && !free_table[i + 1].flag)
{
free_table[i].length += free_table[i + 1].length;
for (int j = i + 1; j < num - 1; j++)
free_table[j] = free_table[j + 1];
i--;
num--;
}
}
}
}
void output1() // 输出空闲区表信息
{
cout << "空闲区表：" << endl << " 起始地址" << "\t" << "长度" << "\t" << "状态" << endl;
for (int i = 0; i < num; i++)
cout << "\t" << free_table[i].address << "\t" << free_table[i].length << "\t" << free_table[i].flag << endl;
cout << endl;
}
void output2() // 输出已分配区表信息
{
cout << "已分配区表:" << endl << " 起始地址" << "\t" << "长度" << "\t" << "状态" << "\t" << "占用作业" << endl;
for (int i = 0; i < p_num; i++)
cout << "\t" << work_table[i].address << "\t" << work_table[i].length << "\t" << work_table[i].flag << "\t" << work_table[i].name << endl;
cout << endl;
}
// 初始化空闲区信息
void init()
{
work_table[0].address = 0;
work_table[0].length = 10;
work_table[0].flag = 1;
strcpy_s(work_table[0].name, "操作系统");
work_table[1].address = 10;
work_table[1].length = 4;
work_table[1].flag = 1;
strcpy_s(work_table[1].name, "1");
work_table[2].address = 32;
work_table[2].length = 96;
work_table[2].flag = 1;
strcpy_s(work_table[2].name, "2");
work_table[3].address = 14;
work_table[3].length = 12;
work_table[3].flag = 1;
strcpy_s(work_table[3].name, "3");
free_table[0].address = 26;
free_table[0].length = 6;
free_table[0].flag = 0;
free_table[1].address = 128;
free_table[1].length = 896;
free_table[1].flag = 0;
sort();
merge();
cout << endl;
sort();
output1();
output2();
}
// 装入作业，分配内存
void input()
{
int i, length;
char name[20];
cout << "输入作业序号: ";
//gets_s(name);
cin >> name;
cout << endl;
cout << "输入作业大小: ";
cin >> length;
fflush(stdin);
for (i = 0; i < num; i++)
{
if (!free_table[i].flag)
{
if (length < free_table[i].length)
{
work_table[p_num].address = free_table[i].address;
free_table[i].length = free_table[i].length - length;
free_table[i].address = free_table[i].address + length;
strcpy_s(work_table[p_num].name, name);
work_table[p_num].flag = 1;
work_table[p_num].length = length;
p_num++;
break;
}
else if (length == free_table[i].length)
{
strcpy_s(work_table[p_num].name, name);
work_table[p_num].flag = 1;
work_table[p_num].address = free_table[i].address;
work_table[p_num].length = free_table[i].length;
p_num++;
for (int j = i; j < num; j++)
{
free_table[j] = free_table[j + 1];
}
num--;
break;
}
}
}
if (i == num)
{
cout << endl << "无合适空闲区，不能为作业分配内存！" << endl;
return;
}
sort();
output1();
output2();
}
// 撤消作业，回收内存
void finish()
{
char name[20];
int i;
cout << "输入作业序号:";
// gets_s(name);
cin >> name;
fflush(stdin);
bool flag = 0;
for (i = 0; i < p_num; i++)
{
if (!strcmp(name, work_table[i].name))
{
free_table[num] = work_table[i];
free_table[num].flag = 0;
num++;
sort();
merge();
for (int j = i; j < p_num; j++)
work_table[j] = work_table[j + 1];
p_num--;
flag = 1;
break;
}
}
if (!flag)
cout << endl << "没有此作业，重新输入！";
output1();
output2();
}
void FIRST_FIT()
{
init();
while (1)
{
int c;
cout << "1.装入作业" << endl << "2.撤销作业" << endl;// << "3.退出" << "请输入你的选择：";
cin >> c;
cout << endl;
fflush(stdin);
if (c == 1)
input();
else if (c == 2)
finish();
else break;
}
}
int main(void)
{
FIRST_FIT();
return 0;
}第四个
#include"stdio.h"
#include"iostream"
#include"cstdio"
#include"iomanip"
#include"malloc.h"
using namespace std;
typedef struct//队列的结构
{
int data[3];//存id，一个队列有2个设备，数组大小设为3是为了循环队列的操作
int front,rear;
}SQue;
typedef struct DeviceCa//设备类表
{
int count=2;//0 录音机 1 摄像头 2 打印机
int sa;//起始位置
int fa;//终止位置
SQue *q;//指向设备队列
}Dec;
typedef struct Devic//设备表
{
int ad;//设备始址
int id;//占用的ID
SQue *q;//也指向设备队列
}De;
void InitQueue(SQue *&l)//创建队列
{
l=(SQue *)malloc(sizeof(SQue));
l->front=l->rear=0;
}
bool Queue(SQue *l)//判断是否为空 1 为空
{
return(l->front==l->rear);
}
bool enQueue(SQue *&l,int e)//进队列
{
if((l->rear+1)%3==l->front )//满队列就不能进了
return 0;
l->rear=(l->rear+1)%3;
l->data[l->rear]=e;
return e;
}
int deQueue(SQue *&l,int e)//出队列
{
if(l->front==l->rear)
return 0;
l->front=(l->front+1)%3;
e=l->data[l->front];
return e;
}
void Insertpro(Dec devc[],De dev[])//插入进程函数
{
int id;//id表示占用设备进程的id
int ca;//ca表示要占用设备的类型
cout<<"请输入程序ID及程序占用设备类型，两者以空格形式隔开(0表示录音机(第一类设备) 1表示摄像头(第二类设备) 2表示打印机(第三类设备)：\n";
cin>> id;
cin>>ca;
if(devc[ca].count!=0)
{
if(dev[devc[ca].sa].id==-1)//查看sa位置是否空闲
{
dev[devc[ca].sa].id=id;
cout<<"插入程序占用设备成功~\n";
}
else
{
dev[devc[ca].fa].id=id;//sa位置不空闲的话就用fa位置
cout<<"插入程序占用设备成功~\n";
}
devc[ca].count--;//插入之后count减1
}
else
{
if(enQueue(devc[ca].q,id))
cout<<"设备忙，程序已进入队列\n";
else
cout<<"队列满，请稍后重试\n" ;
}
}
void Recycle(Dec devc[],De dev[])//回收函数
{
int h=0;
int id=-1;
cout<<"请输入回收程序ID：";
cin>>id;
int j=-1;//用于判断
for(int i=0;i<6;i++)
{
if(dev[i].id==id)
{
cout<<"回收成功！\n";
j=i;
break;
}
}
if(j==-1)
cout<<"程序查找失败,无法回收\n";
else
{
if(Queue(dev[j].q))//如果等待队列为空
{
dev[j].id=-1;
devc[j/2].count++;
}
else
{
dev[j].id=deQueue(dev[j].q,h);//等待队列不空，要在设备表上登记等待队列中的设备
}
}
}
void Findid(De dev[])//查找函数
{
int getid;
int j=-1;//j可以判断对应id存在不存在
cout<<"请输入查找的ID：\n";
cin>>getid;
for(int i=0;i<6;i++)
{
if(dev[i].id==getid)
{
cout<<"进程绝对号为："<<i;
cout<<"\n进程为第"<<i/2+1<<"类"<<"第"<<i%2+1<<"个设备\n";
j=1;
break;
}
}
if(j==-1)
cout<<"程序不存在\n";
}
int main()
{
cout<<"------本实验中，设备队列大小为2，同一类设备最多允许两台设备等待------\n";
Dec devc[3];//有3类设备
De dev[6];//所有队列一共6台设备
for(int i=0;i<3;i++)
{
devc[i].count=2;
devc[i].sa=i*2;
devc[i].fa=devc[i].sa+1;
InitQueue(devc[i].q);
}
int ee=0;
for(int i=0;i<6;i=i+2)
{
dev[i].ad=i;
dev[i+1].ad=i+1;
dev[i].id=-1;//表示无进程占用
dev[i+1].id=-1 ;
dev[i].q=devc[ee].q;
dev[i+1].q=devc[ee].q;
ee++;
}
int gets=-1;//gets用于捕获操作类型
while(1)
{
cout<<"\n------------------------\n请选择操作类型(0为插入程序，1为回收程序,2为搜索程序位置)：\n";
cin>>gets;
if(gets==0)
{
Insertpro(devc,dev);
}
else if(gets==1)
{
Recycle(devc,dev);
}
else if(gets==2)
{
Findid(dev);
}
}
}
5784
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
