我们课程设计，我选择了一个进程调度模拟，希望大家给看看，多提意见，好久没来发帖子了。

　　#include<iostream.h>

　　#include<stdlib.h>

　　#include<time.h>

　　#include<stdio.h>

　　#include<string.h> const int MAXCOMMANDLEN =50; /////////////////////////////////////////////////////////////////////////////////////

　　//

　　// PROCESS

　　//

　　/////////////////////////////////////////////////////////////////////////////////////

　　class Process //进程类

　　{

　　friend class CPU;

　　protected:

　　static int init_ID; //随机进程ID

　　int ID; //进程ID

　　char runText[MAXCOMMANDLEN]; //进程指令数组

　　int IP; //进程指令指针，保存进程指令执行到的具体位置

　　bool ISuseSource; //此进程是否使用资源，ture:使用中 false : 未使用

　　bool ISblocked; //此进程是否被阻塞 ture:阻塞 false :未阻塞

　　int unitTime; //进程单位被cpu执行时间, 默认 1

　　int blockTime; //进程被阻塞时间

　　public:

　　static void RandID(); //随机生成进程ID

　　Process();

　　int getID();

　　int getIP();

　　void setIP(int);

　　void Runed(); //进程被cpu执行

　　int getUnittime(); //得到进程单位执行时间

　　int getBlcoktime(); //得到进程阻塞时间

　　void setBlocktime(int); //设置进程阻塞时间

　　void setUnittime(int); //设置进程单位执行时间

　　char getResult(int); //得到进程执行结果

　　char* getRuntext(); //得到进程执行的指令

　　void setBlockstate(bool); //设置阻塞状态

　　bool getBlockstate();

　　bool getISusesource(); //得到资源的状态 使用 未使用

　　void setISusesource(bool); //设置资源的使用状态

　　}; int Process::init_ID; void Process::RandID()

　　{

　　srand( (unsigned)time( NULL ) );

　　init_ID=rand();

　　}

　　Process::Process()

　　{

　　ID=init_ID++;

　　int commandLen;

　　IP=0; cout<<"Please in put the text which process runed by CPU [#command#] :> ";

　　cin>>runText;

　　if( (commandLen=strlen(runText) ) > MAXCOMMANDLEN )

　　exit(0);

　　runText[commandLen]='#'; // 指令结束标志 '#'

　　runText[commandLen+1]='';

　　ISuseSource=false;

　　ISblocked=false;

　　unitTime=1;

　　blockTime=0;

　　}

　　void Process::Runed()

　　int Process::getID()

　　{

　　return ID;

　　} int Process::getIP()

　　{

　　return IP;

　　} void Process::setIP(int ip)

　　bool Process::getISusesource()

　　{

　　return ISuseSource;

　　} void Process::setISusesource(bool s)

　　char* Process::getRuntext()

　　{

　　return runText;

　　} int Process::getUnittime()

　　{

　　return unitTime;

　　}

　　int Process::getBlcoktime()

　　{

　　return blockTime;

　　} void Process::setBlocktime(int BT)

　　void Process::setUnittime(int UT)

　　void Process::setBlockstate(bool state)

　　bool Process::getBlockstate()

　　{

　　return ISblocked;

　　} char Process::getResult(int k)

　　{

　　return runText[k];

　　} /////////////////////////////////////////////////////////////////////////////////////

　　//

　　// SOURCE

　　//

　　///////////////////////////////////////////////////////////////////////////////////// class Source //资源类

　　{

　　protected:

　　int ID; //资源 ID

　　bool state; //资源状态 true : 未被进程占有 false : 已被占有

　　int pro_ID; //使用资源的进程id

　　Process *pro; //使用资源的进程指针

　　int time; //进程使用资源的时间

　　public:

　　Source(int);

　　bool getState(); //得到进程状态

　　void setState(bool); //设置进程状态

　　void setTime(int); //设置进程使用资源的时间

　　void setPro(Process *); //设置使用该资源的进程

　　int getID(); //得到资源id

　　int getPorID(); //得到使用资源的进程id

　　void setProID(int); //设置使用资源的进程id

　　void runned(); //资源被cpu调用

　　}; Source::Source(int id)

　　void Source::setProID(int id)

　　void Source::setTime(int t)

　　void Source::setState(bool s)

　　bool Source::getState()

　　{

　　return state;

　　} void Source::setPro(Process *p)

　　void Source::runned()

　　{

　　if(time>0)

　　{

　　cout<<"( Source :"<<ID<<")";

　　time--;

　　}

　　if(time<=0) //进程使用完资源释放资源，使用资源的时间到

　　{

　　pro->setISusesource(false);

　　int ip=pro->getIP();

　　pro->setIP(++ip);

　　Source::setState(true);

　　cout<<endl<<"The process "<<pro->getID()<<" relase the source!"<<endl;

　　pro=NULL;

　　}

　　} /////////////////////////////////////////////////////////////////////////////////////

　　//

　　// CPU

　　//

　　///////////////////////////////////////////////////////////////////////////////////// typedef strUCt Block //阻塞队列结构

　　{

　　Process *p_BlockProcess; //被阻塞的进程队列

　　int index; //被阻塞的进程在就绪队列中的索引(位置)

　　}Block; class CPU

　　{

　　protected:

　　Process *p_Process; //进程队列

　　Process **pp_Process; //进程就绪队列

　　Block *blockQueue ; //进程阻塞队列

　　Source *p_Source; //资源指针

　　int numOfprocess; //进程数量

　　int numOfblock; //被阻塞的进程数

　　int PC; //程序计数器

　　int allTime; //cpu运行的总时间

　　public :

　　CPU(int);

　　void Run(); //cpu运行进程

　　bool _IC(Process&); //虚拟IC,进行进程指令翻译

　　void useSource(Process&); //进程申请资源

　　void blockProcess(Process&); //阻塞进程

　　void releaseBlockPro(); //释放阻塞进程

　　int getAlltime(); //得到进程运行的总时间

　　void displayPro(); //显示进程的基本信息，id,指令,运行时间等

　　void blockTimeADD(); //阻塞时间加1

　　}; CPU::CPU(int num)

　　{

　　p_Source=new Source(379857);

　　numOfprocess=num;

　　numOfblock=0;

　　allTime=0;

　　p_Process=new Process[numOfprocess];

　　pp_Process=new Process*[numOfprocess];

　　blockQueue=new Block[numOfprocess];

　　for(int i=0;i<numOfprocess;i++)

　　} int CPU::getAlltime()

　　{

　　return allTime;

　　} void CPU::displayPro()

　　{

　　for(int i=0;i<numOfprocess;i++)

　　{

　　cout<<" Process ID : "<<p_Process[i].getID()<<endl;

　　cout<<" text of runned :"<<p_Process[i].getRuntext()<<endl;

　　}

　　} void CPU::Run()

　　{

　　int numPro=numOfprocess; do

　　{

　　for(int num=0;num < numOfprocess;num++)

　　{

　　if(!pp_Process[num]) //假如该指针为空，说明该进程不在就绪队列中

　　continue; for(int t=0;t<p_Process[num].getUnittime();t++)

　　{

　　PC=p_Process[num].getIP();

　　if(_IC(p_Process[num]))

　　{

　　if(t==0)

　　cout<<"the process ["<<p_Process[num].getID()<<"] runed : ";

　　if(!p_P