[C++] Rozserzony symulator dzialania procesora

/*
Zasymulować działanie procesora. Na wykonanie czeka kolejka procesów. Każdy jest opisany za pomocą pary:
identyfikator (kolejny numer tworzony przy dodawaniu procesu do kolejki), czas potrzebny do zakończenia
realizacji. Każdy proces z kolejki ma przydzielany kwant czasu. Jeżeli po tym kwancie proces się nie zakończy
to wędruje na koniec kolejki i czeka na przydzielenie kolejnego kwantu. Procesy są generowane z losową
częstotliwością i mają losowe czasy wykonania. Ograniczyć liczbę tworzonych procesów. Przy wkładaniu
procesu do kolejki raportować jego identyfikator i czas. Po zakończeniu wszystkich procesów wyświetlić czas,
który upłynął do ich zakończenia.
Do obsługi kolejki wykorzystać szablon queue.

+

Wykonać zadanie 5 przy założeniu, że dane poszczególnych procesów są pobierane z pliku zawierającego:
	-opóźnienie dla procesu,
	-czas potrzebny na jego dokończenie. CZYLI NASZ PROCES.EXECtIME

	Opóźnienie-czas, jaki zużywamy na wstrzymanie jednego procesu i uaktywnienie innego
*/

#include "stdafx.h"
#include <queue>
#include <cstdlib>
#include <iostream>
#include <string>
#include <fstream>

class proces{
public:
	int id;
	int execTime;
};

#define execTimeRange 100 //zakres czasu realizaci
#define numOfProc 10 //

using namespace std;

proces createProces( queue <proces> procesorQueue){
	proces proc;
	proc.id = procesorQueue.size() + 1;
	proc.execTime = (rand() % execTimeRange) + 1;
	return proc;
}
void showProces(proces proc){
	cout << "id: " << proc.id << " czas realizacji: " << proc.execTime << endl;
}


int _tmain(int argc, _TCHAR* argv[]){

	queue <proces> procesorQueue, backupQueue;
	proces proc;

	int	time = 0,
		delay = 0,
		fileNumPointer = 0,
		quantum = rand() % execTimeRange;

	cout << "Kwant czasu wynosi " << quantum << "\n---------------------------\n";

	cout <<"Ilosc procesow wynosi: "<< numOfProc <<":\n\n";

	/*
	Wykonać zadanie 5 przy założeniu, że dane poszczególnych procesów są pobierane z pliku zawierającego:
	-opóźnienie dla procesu,
	-czas potrzebny na jego dokończenie. CZYLI NASZ PROCES.EXECtIME

	Opóźnienie
	czas, jaki zużywamy na wstrzymanie jednego procesu i uaktywnienie innego
	 */

	//otwieramy plik z danymi do pobrania
	fstream file;
	file.open( "text.txt" , std::ios::in | std::ios::out);
	if( file.good() == false )exit (0);

	//tworzymy vector(czyli taka tablica) i wrzucamy do niej wartosci z pliku
	vector <string> fileNum;
	string line;
	while(getline(file,line)){
		fileNum.push_back(line);
	}

	//wkladamy do naszej backupQueue procesy: 50% ze proces pobiera dane z pliku + ma opoznienie, 50% ze tworzymy go losujac mu execTime losowo
	for(int i = 0; i < numOfProc; i++){
		if(rand()%2){
			delay = atoi( fileNum[ fileNumPointer++ ].c_str());
			proc.execTime = atoi( fileNum[ fileNumPointer++ ].c_str());
			proc.execTime += delay;
			proc.id = backupQueue.size() + 1;
			backupQueue.push(proc);
		}else{
			backupQueue.push(createProces(backupQueue));
			proc = backupQueue.back();
		}
		showProces(proc);
	}
	cout << "........................\n";

	while( (!backupQueue.empty()) || (!procesorQueue.empty()) ){
		if((!backupQueue.empty())){
			if(rand()%2){
				proc = backupQueue.front();
				procesorQueue.push(proc);
				cout << "dodano             ";showProces(proc);
				backupQueue.pop();
			}
		}
		if(!procesorQueue.empty()){
			proc = procesorQueue.front();
			cout << "procesor wykonuje: ";showProces(proc);
			if(proc.execTime >= quantum){
				time += quantum;
				proc.execTime -= quantum;
				procesorQueue.push(proc);
				if(procesorQueue.size() > 0) procesorQueue.pop();
			}else{
				cout << "wykonano           ";showProces(proc);
				time += proc.execTime;
				if(procesorQueue.size() > 0) procesorQueue.pop();
			}
		}
	}
	cout << "\nCzas ktory uplynal do zakonczenia procesow " << time << "\n\n";

	system ("PAUSE");
}