操作系统实验报告 - 图文

课内实验报告

课 程 名： 操作系统 任课教师： 专 业： 信息管理与信息系统 学 号： 姓 名：

二○一五至二○一六 年度 第 一 学期

XXXX大学 管理学院

1

《 操作系统 》课程实验第 一 次实验报告 一、实验目的与基本要求 1、了解进程管理的实现方法； 2、理解和掌握处理进程同步问题的方法。 二、实验仪器与设备 硬件：微型计算机。中央处理器PentiumIV以上；显示器256色VGA以上；内存使用128兆；硬盘300M以上。 软件：学生可以采用任何一种自己熟悉的编程语言完成算法的程序设计，如C/C++、Delphi、VB、VC、C#等。 三、实验内容： 实现银行家算法、进程调度过程的模拟、读者-写者问题的写者优先算法。 实验结果： 银行家算法原理： 我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。为保证资金的安全, 银行家规定: (1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客; (2) 顾客可以分期贷款,但贷款的总数不能超过最大需求量; (3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款; (4) 当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金. 操作系统按照银行家制定的规则为进程分配资源， 当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系 统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程本次申请的资源数是否超过了该资源所剩余的总量。若超过则拒绝分配资源，若能满足则按当前的申请量分配资源，否则也要推迟分配。 银行家算法 进程i发出请求资源申请， (1)如果Request [j]<=need[i,j],转向步骤(2),否则认为出错，因为他所需要的资源数已经超过它所宣布的最大值。 (2)如果：Request i[j]<=available[i,j]，转向步骤(3)，否则表示尚无足够资源，进程i需等待。 (3)若以上两个条件都满足，则系统试探着将资源分配给申请的进程，并修改下面数据结构中的数值：

2

可利用资源向量Available[i,j]= Available[i,j]- 最大需求矩阵Request [j]； 分配矩阵Allocation[i][j]= Allocation[i][j]+ Request [j]； 需求矩阵need[i][j]= need[i][j]- Request [j]； (4)试分配后，执行安全性检查，调用check()函数检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程；否则本次试探分配作废，恢复原来的资源分配状态，让该进程等待。 (5)用do{…}while 循环语句实现输入字符y/n判断是否继续进行资源申请。 安全性检测算法 (1) 设置两个向量： 工作向量Work，它表示系统可提供给进程继续运行所需的各类资源数目，在执行安全性算法开始时，Work= Available。 工作向量Finish，它表示系统是否有足够的资源分配给进程，使之运行完成。 开始时先做Finish[i]=false；当有足够的资源分配给进程时，再令Finish[i]=true。 (2)在进程中查找符合以下条件的进程： 条件1：Finish[i]=false； 条件2：need[i][j]<=Work[j] 若找到，则执行步骤(3)否则，执行步骤(4) (3)当进程获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：Work[j]= Work[j]+ Allocation[i][j]； Finish[i]=true； goto step (2)； (4)如果所有的Finish[i]=true都满足，则表示系统处于安全状态，否则，处于不安全状态。 流程图 程序源代码 #include #include #include #include # define m 50 int no1; //进程数 int no2; //资源数 int r; int allocation[m][m],need[m][m],available[m],max[m][m]; char name1[m],name2[m]; //定义全局变量 void main() { void check(); 3

void print(); int i,j,p=0,q=0; char c; int request[m],allocation1[m][m],need1[m][m],available1[m]; printf(\ printf(\银行家算法的设计与实现 *\\n\ printf(\ printf(\请输入进程总数:\\n\ scanf(\ printf(\请输入资源种类数:\\n\ scanf(\ printf(\请输入Max矩阵:\\n\ for(i=0;i=no1) { 4

printf(\输入错误，请重新输入：\\n\ continue; } else break; } printf(\请输入该进程所请求的资源数request[j]:\\n\ for(j=0;jneed[i][j]) p=1; //判断请求是否超过该进程所需要的资源数 if(p) printf(\请求资源超过该进程资源需求量，请求失败！\\n\ else { for(j=0;javailable[j]) q=1; //判断请求是否超过可用资源数 if(q) printf(\没有做够的资源分配，请求失败！\\n\ else //请求满足条件 { for(j=0;j

{ available[j]=available1[j]; allocation[i][j]=allocation1[i][j]; need[i][j]=need1[i][j]; //还原已分配的资源数，仍需要的资源数和可用的资源数 } printf(\返回分配前资源数\\n\ print(); } } } printf(\你还要继续分配吗？Y or N ?\\n\ //判断是否继续进行资源分配 c=getche(); } while(c=='y'||c=='Y'); } void check() //安全算法函数 { int k,f,v=0,i,j; int work[m],a[m]; bool finish[m]; r=1; for(i=0;iwork[j]) f=0; 6

if(f==1) //找到还没有完成且需求数小于可提供进程继续运行的资源数的进程 { finish[i]=true; a[v++]=i; //记录安全序列号 for(j=0;j0); f=1; for(i=0;i

printf(\此时刻资源分配情况*********************\\n\ printf(\进程名/号| Max | Allocation | Need |\\n\ for (i = 0; i < no1; i++) { printf(\ p%d/%d \ for (j = 0; j < no2; j++) { printf(\ \} for (j = 0; j < no2; j++) { printf(\ \} for (j = 0; j < no2; j++) { printf(\ \} printf(\ } printf(\ printf(\各类资源可利用的资源数为:\ for (j = 0; j < no2; j++) { printf(\} printf(\ } 进程调度过程的模拟、 （1）概述 选择一个调度算法，实现处理机调度。 设计要求： 1）进程调度算法包括：先来先服务算法，时间片轮转算法，短进程优先算法， 动态优先级算法。 2）可选择进程数量 3）本程序包括四种算法，用C或C++语言实现，执行时在主界面选择算法（可 用函数实现），进入子页面后输入进程数，（运行时间，优先数由随机函数产生）， 执行，显示结果。 8

（2）设计原理 1）先来先服务算法 FCFS 每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作 业，将它们调入内存，为它们分配资源创建进程，然后放入就绪队列。 2）时间片轮转法RR 系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。时间片的大小从几ms到几百ms。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。 (3) 短进程优先算法 SPF短进程优先调度算法是从就绪队列中选出一个估计运行时间最短的进程， 将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。 （4）动态优先级算法 优先权调度算法是为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入最高优先权优先调度算法。动态优先权是指在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能。 #include #include #include using namespace std; #define P_NUM 3 //进程数 #define P_TIME 2//时间片长度 #define MIN -9999 enum state //进程状态 { ready, //就绪 run, //执行 wait, //阻塞 finish //完成 }; class Pcb { public: 9

static void print(){}; ~Pcb(); protected: char* name; //进程名 int allTime; //需要运行时间 int cpuTime; //已用cpu时间 state process; //进程状态 }; class HPcb:public Pcb { public: static void print(); static void highS(); static int getFirst(); private: int firstNum; }; HPcb hpcb[P_NUM]; class FPcb:public Pcb { public: static void print(); static void fcfs(); private: int comeTime; }; FPcb fpcb[P_NUM]; class RPcb:public Pcb { public: static void print(); static void rr(); }; RPcb rpcb[P_NUM]; void RPcb::rr() { int ii,i=0; int k=0; 10

for(;i>ch; rpcb[i].name=new char[strlen(ch)+1]; strcpy(rpcb[i].name,ch); cin>>rpcb[i].allTime; rpcb[i].cpuTime=0; rpcb[i].process=ready; } do { for(i=0;i=rpcb[i].allTime)//该进程执行完成 { rpcb[i].cpuTime-=P_TIME; system(\ print(); Sleep(1000); rpcb[i].process=finish; rpcb[i].cpuTime=rpcb[i].allTime;//防止所用时间超过总的时间 system(\ print(); Sleep(1000); } else { rpcb[i].cpuTime-=P_TIME; system(\ print(); Sleep(1000); rpcb[i].cpuTime+=P_TIME; rpcb[i].process=ready; 11

} } } for(i=0;i=rpcb[i].allTime)//该进程执行完成 { rpcb[i].process=finish; rpcb[i].cpuTime=rpcb[i].allTime;//防止所用时间超过总的时间 system(\ print(); Sleep(1000); } else { system(\ print(); Sleep(1000); rpcb[i].process=run; } } for(ii=0;ii

char* ch; ch=new char[1]; cout<<\请输入第\个进程的进程名优先、需要运行的时间：\ cin>>ch; hpcb[i].name=new char[strlen(ch)+1]; strcpy(hpcb[i].name,ch); cin>>hpcb[i].firstNum>>hpcb[i].allTime; hpcb[i].cpuTime=0; hpcb[i].process=ready; } do { f=getFirst(); hpcb[f].cpuTime+=P_TIME; hpcb[f].firstNum--; hpcb[f].process=run; if(hpcb[f].cpuTime>=hpcb[f].allTime)//该进程执行完成 { hpcb[f].cpuTime-=P_TIME; system(\ print(); Sleep(1000); hpcb[f].firstNum=MIN; hpcb[f].process=finish; hpcb[f].cpuTime=hpcb[f].allTime;//防止所用时间超过总的时间 system(\ print(); Sleep(1000); } else { hpcb[f].cpuTime-=P_TIME;//为了输出改变前的相关信息 hpcb[f].firstNum++;//为了输出改变前的相关信息 system(\ print(); Sleep(1000); hpcb[f].cpuTime+=P_TIME; hpcb[f].firstNum--; 13

hpcb[f].process=ready; } for(ii=0;ii>ch; fpcb[i].name=new char[strlen(ch)+1]; strcpy(fpcb[i].name,ch); cin>>fpcb[i].allTime; fpcb[i].comeTime=i+1; fpcb[i].cpuTime=0; fpcb[i].process=ready; } for(i=0;i=fpcb[i].allTime) { 14

if((i+1)!=P_NUM) //如果第i+1个进程不是最后一个进程,便于下一个程序从就绪状态到运行状态 { fpcb[i].cpuTime-=P_TIME; system(\ print(); Sleep(1000); fpcb[i].cpuTime+=P_TIME; fpcb[i].cpuTime=fpcb[i].allTime; fpcb[i].process=finish; fpcb[i+1].process=run; system(\ print(); Sleep(1000); } else { fpcb[i].cpuTime-=P_TIME; system(\ print(); Sleep(1000); fpcb[i].process=finish; fpcb[i].cpuTime=fpcb[i].allTime; system(\ print(); Sleep(1000); } } else { fpcb[i].cpuTime-=P_TIME; system(\ print(); Sleep(1000); fpcb[i].cpuTime+=P_TIME; } } } cout<<\所有进程已运行完成！\ 15

} int HPcb::getFirst() //得到优先级最高的进程 { int k=0; for(int i=1;i

cout<

cin>>ch; if(ch=='1') FPcb::fcfs(); else if(ch=='2') RPcb::rr(); else if(ch=='3') HPcb::highS(); } 设有一文件F，多个并发读进程和写进程都要访问，要求： (1)读写互斥 (2)写写互斥 (3)允许多个读进程同时访问 采用记录型信号量机制解决 semaphore fmutex=1, rdcntmutex=1; //fmutex --> access to file; rdcntmutex --> access to readcount int readcount = 0; void reader(){ while(1){

18

wait(rdcntmutex);

if(0 == readcount)wait(fmutex); readcount = readcount + 1; signal(rdcntmutex); //Do read operation ... wait(rdcntmutex); readcount = readcount - 1; if(0 == readcount)signal(fmutex); signal(rdcntmutex); } }

void writer(){ while(1){ wait(fmutex); //Do write operation ... signal(fmutex); } }

读进程只要看到有其他读进程正在访问文件，就可以继续作读访问；写进程必须等待所有读进程都不访问时才能写文件，即使写进程可能比一些读进程更早提出申请。所以以上解法实际是 读者优先 的解法。如果在读访问非常频繁的场合，有可能造成写进程一直无法访问文件的局面....

为了解决以上问题，需要提高写进程的优先级。这里另增加一个排队信号量：queue。读写进程访问文件前都要在此信号量上排队，通过区别对待读写进程便可达到提高写进程优先级的目的。另外再增加一个 writecount 以记录提出写访问申请和正在写的进程总数 //wtcntmutex --> access to writecount

int readcount = 0, writecount = 0; void reader(){ while(1){ wait(queue); wait(rdcntmutex);

if(0 == readcount)wait(fmutex); readcount = readcount + 1; signal(rdcntmutex);

19

signal(queue); //Do read operation ... wait(rdcntmutex); readcount = readcount - 1; if(0 == readcount)signal(fmutex); signal(rdcntmutex); } }

void writer(){ while(1){

wait(wtcntmutex);

if(0 == writecount)wait(queue); writecount = writecount + 1; signal(wtcntmutex); wait(fmutex); //Do write operation ... signal(fmutex); wait(wtcntmutex); writecount = writecount - 1; if(0 == writecount)signal(queue);

signal(wtcntmutex);

} }

每个读进程最开始都要申请一下 queue 信号量，之后在真正做读操作前即让出(使得写进程可以随时申请到 queue)。而只有第一个写进程需要申请 queue，之后就一直占着不放了，直到所有写进程都完成后才让出。等于只要有写进程提出申请就禁止读进程排队，变相提高了写进程的优先级。

通过类似思想即可实现读写进程的公平竞争：

semaphore fmutex=1, rdcntmutex=1, queue=1;

//fmutex --> access to file; rdcntmutex --> access to readcount int readcount = 0; void reader(){ while(1){ wait(queue);

20

wait(rdcntmutex); if(0 == readcount)wait(fmutex); readcount = readcount + 1; signal(rdcntmutex); signal(queue); //Do read operation ... wait(rdcntmutex); readcount = readcount - 1; if(0 == readcount)signal(fmutex); signal(rdcntmutex); } } void writer(){ while(1){ wait(queue); wait(fmutex); signal(queue); //Do write operation ... signal(fmutex); } } } 读进程没变，写进程变成在每次写操作前都要等待 queue 信号量。 成绩评定： 该生对待本次实验的态度 □认真 □良好 □一般 □比较差。 本次实验的过程情况 □很好 □较好 □一般 □比较差 对实验结果的分析 □很好 □良好 □一般 □比较差 文档书写符合规范程度 □很好 □良好 □一般 □比较差 综合意见 成绩 指导教师签名 日期 21

《 操作系统 》课程实验第 二 次实验报告 实验内容及基本要求： 一、实验目的与基本要求 1、理解各类置换算法的原理 2、理解虚拟存储器管理的方法 二、实验仪器与设备 硬件：微型计算机。中央处理器PentiumIV以上；显示器256色VGA以上；内存使用128兆；硬盘300M以上。 软件：学生可以采用任何一种自己熟悉的编程语言完成算法的程序设计，如C/C++、Delphi、VB、VC、C#等。 三、实验内容： 编程实现LRU算法或CLOCK/改进算法等置换算法（二选一），模拟实现虚拟存储器的地址变换过程。 实验结果： #include using namespace std; int size; int *w; //定义一个动态数组 struct mem { int num; int count; } memBlock[3]={0,0,0,0,0,0}; void LRU() { for( int i = 0; i < size; i++ ) { int maxCount = memBlock[0].count; int maxPos = 0; int j = 0; bool bFind = false; for( j = 0; j < 3; j++ )

{ // 标记出count值最大的位置 22

if( maxCount < memBlock[j].count ) { maxCount = memBlock[j].count; maxPos = j; } // 将所有的count值都+1 memBlock[j].count++; // 如果命中，将其count值置为0 if( w[i] == memBlock[j].num ) { memBlock[j].count = 0; bFind = true; } } // 未命中，将count最大的拿来替换 if( !bFind ) { memBlock[maxPos].num = w[i]; memBlock[maxPos].count = 0; } for(j = 0; j < 3; j++) //输出 cout << memBlock[j].num << \ cout <<\ } } int main() //主函数 { cout<<\请输入需访问的页面数量:\ cin>>size; w = new int[size]; cout<<\请输入需要访问的页面\ for(int a=0;a>w[a];//输入数组 } cout<

成绩评定： 该生对待本次实验的态度 □认真 □良好 □一般 □比较差。 本次实验的过程情况 □很好 □较好 □一般 □比较差 对实验结果的分析 □很好 □良好 □一般 □比较差 文档书写符合规范程度 □很好 □良好 □一般 □比较差 综合意见： 成绩 指导教师签名 日期

24

《 操作系统 》课程实验第 三次实验报告 实验内容及基本要求： 一、实验目的与基本要求 1、理解磁盘调度算法的设计 2、理解提高磁盘访问速度的原理 二、实验仪器与设备 硬件：微型计算机。中央处理器PentiumIV以上；显示器256色VGA以上；内存使用128兆；硬盘300M以上。 软件：学生可以采用任何一种自己熟悉的编程语言完成算法的程序设计，如C/C++、Delphi、VB、VC、C#等。 三、实验内容： 模拟实现磁盘调度算法：最短寻道时间优先（SSTF）和扫描（SCAN）算法。 实验结果： #include #include #include #include #define maxsize 1000 int decide(char str[]) //判断输入数据是否有效 { int i=0; while(str[i]!='\\0') { if(str[i]<'0'||str[i]>'9') { return 0; break; } i++; } return i; } int trans(char str[],int a) //将字符串转换成数字 { int i;

25

int sum=0; for(i=0;icidao[j]) { temp=cidao[i]; cidao[i]=cidao[j]; cidao[j]=temp; } } cout<<\排序后的磁盘序列为：\ for( i=0;i

float ave; cidao=bubble(cidao,m); //调用冒泡排序算法排序 cout<<\请输入当前的磁道号：\ C: cin>>str; //对输入数据进行有效性判断 a=decide(str); if(a==0) { cout<<\输入数据的类型错误,请重新输入！\ goto C; } else now=trans(str,a); //输入当前磁道号 if(cidao[m-1]<=now) //若当前磁道号大于请求序列中最大者，则直接由外向内依次给予各请求服务 { cout<<\磁盘扫描序列为：\ for(i=m-1;i>=0;i--) cout<=now) //若当前磁道号小于请求序列中最小者，则直接由内向外依次给予各请求服务 { cout<<\磁盘扫描序列为：\ for(i=0;icidao[0]&&now

while((l>=0)&&(r=0;j--) { cout<

void SCAN(int cidao[],int m) //先要给出当前磁道号和移动臂的移动方向 { int k=1; int now,l,r,d; int i,j,sum=0; int a; char str[100]; float ave; cidao=bubble(cidao,m); //调用冒泡排序算法排序 cout<<\请输入当前的磁道号：\ D: cin>>str; //对输入数据进行有效性判断 a=decide(str); if(a==0) { cout<<\输入数据的类型错误,请重新输入！\ goto D; } else now=trans(str,a); //输入当前磁道号 if(cidao[m-1]<=now) { cout<<\磁盘扫描序列为：\ for(i=m-1;i>=0;i--) cout<=now) { cout<<\磁盘扫描序列为：\ for(i=0;icidao[0]&&now

} l=k-1; r=k; cout<<\请输入当前移动臂的移动的方向(1表示向外，0表示向内) : \ cin>>d; if(d==0) //选择移动臂方向向内，则先向内扫描 { cout<<\磁盘扫描序列为：\ for(j=l;j>=0;j--) { cout<=0;j--) { cout<

int a; int c; //菜单项 int cidao[maxsize]; int i=0,count; char str[100]; cout<<\请输入磁道序列（0结束）：\ A:cin>>str; //对输入数据进行有效性判断 a=decide(str); if(a==0) { cout<<\输入数据的类型错误,请重新输入！\ goto A;//输入错误，跳转到A，重新输入 } else cidao[i]=trans(str,a); i++; while(cidao[i-1]!=0) { cin>>str; //对输入数据进行有效性判断 a=decide(str); if(a==0) cout<<\输入数据的类型错误,请重新输入！\ else { cidao[i]=trans(str,a); i++; } } count=i-1; //要访问的磁道数 cout<<\你输入的磁道序列为：\ for(i=0;i

{ cout<>str; //对输入数据进行有效性判断 a=decide(str); if(a==0) { cout<<\输入数据的类型错误,请重新输入！\ goto F;//输入错误，跳转到F，重新输入 } else c=trans(str,a); if(c==0) break; if(c>2) { cout<<\数据输入错误！请重新输入\ goto G; } switch(c) { case 1: //使用SSTF算法 SSTF(cidao,count); break; case 2: //使用SCAN算法 SCAN(cidao,count); break; } } } 32

成绩评定： 该生对待本次实验的态度 □认真 □良好 □一般 □比较差。 本次实验的过程情况 □很好 □较好 □一般 □比较差 对实验结果的分析 □很好 □良好 □一般 □比较差 文档书写符合规范程度 □很好 □良好 □一般 □比较差 综合意见： 成绩 指导教师签名 沈超 日期

33

《 操作系统 》课程实验第 四 次实验报告 实验内容及基本要求： 一、实验目的与基本要求 1、了解操作系统中文件系统的结构和管理过程。 2、掌握经典的算法：混合索引与成组链接法等方法。 二、实验仪器与设备 硬件：微型计算机。中央处理器PentiumIV以上；显示器256色VGA以上；内存使用128兆；硬盘300M以上。 软件：学生可以采用任何一种自己熟悉的编程语言完成算法的程序设计，如C/C++、Delphi、VB、VC、C#等。 三、实验内容： 编程模拟实现混合索引和成组链接法算法。 实验结果： 1.实验目的： 了解操作系统中文件系统的结构和管理过程，掌握经典的算法：混合索引与成组链接法等方法。 2.实验内容：编程模拟实现混合索引和成组链接法算法； 3.实验步骤： （1）模拟混合索引的原理；假设每个盘块16字节大小，每个盘块号占2字节： 设计支持混合索引算法的索引节点的数据结构；编程模拟实现混合索引算法。 测试：输入一个文件的长度，给出模拟分配占用的磁盘块的情况；输入一个需要访问的地址，计算该地址所在的盘块号。 （2）模拟成组链接法的原理； 设系统具有7个可用磁盘块，每组3块。 编程模拟实现成组链接法。输入请求的磁盘块数，模拟成组链接分配；输入回收的 磁盘块号，模拟成组链接回收。 测试：输入请求的磁盘块数，给出分配后的链接情况。输入回收的磁盘块号， 给出回收后的链接情况。 4.实验思想： #include int MA[4]; /*空闲块数组*/ int A[9][4]={{3,1,2,3},{3,4,5,6},{0,0,0,0},{0,0,0,0},{3,0,7,8}, {0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}}; /*磁盘空间*/ int mark[9]; /*存放已分配的块*/ int No=0; /*已分配的块数*/

34

#include int MA[4]; int A[9][4]={{3,1,2,3},{3,4,5,6},{0,0,0,0},{0,0,0,0},{3,0,7,8}, {0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}}; int mark[9]; int No=0; void display1() { int i,j,temp,count; No=0; if(MA[1]!=0) { i=MA[0]; printf(\ for(j=1;j<=i;j++) { printf(\ mark[++No]=MA[j]； } temp=MA[1]; count=2; while(A[temp][1]!=0) { printf(\ i=A[temp][0]; for(j=1;j<=i;j++) { printf(\ \ mark[++No]=A[temp][j]； } count++; temp=A[temp][1]; } printf(\ i=A[temp][0]; for(j=2;j<=i+1;j++) if(A[temp][j]>0) { printf(\ \ mark[++No]=A[temp][j]; } } else { i=MA[0]; if(i==1) printf(\ else 35

{ printf(\ for(j=2;j<=i;j++) { printf(\ \ mark[++No]=MA[j]; } } } void display() { int i,j; if(MA[0]!=0) display1(); else { i=MA[1]; for(j=0;j<=3;j++) MA[j]=A[i][j]; display1(); } } void assign() { int s,i; if(MA[0]>1) { i=MA[0]; s=MA[i]; MA[0]--; printf(\ } else if(MA[0]==1) { if(MA[1]!=0) { s=MA[1]; for(i=0;i<=3;i++) A[0][i]=A[s][i]; MA[0]--; printf(\ } else { printf(\ return; } } else { for(i=0;i<=3;i++) MA[i]=A[0][i]; assign(); } display(); } void callback() { int i,j,temp; printf(\ 36

scanf(\ getchar(); for(temp=1;temp<=No;temp++) { if(mark[temp]==j) break; } if(temp

display(); printf(\ getch(); } } main() { int i; for(i=0;i<=3;i++) MA[i]=A[0][i]; display(); menu(); } 成绩评定： 该生对待本次实验的态度 □认真 □良好 □一般 □比较差。 本次实验的过程情况 □很好 □较好 □一般 □比较差 对实验结果的分析 □很好 □良好 □一般 □比较差 文档书写符合规范程度 □很好 □良好 □一般 □比较差 综合意见： 成绩 指导教师签名 沈超 日期

38

本文来源：https://www.bwwdw.com/article/arog.html