磁盘调度与管理 c++

#include <iostream>  
#include <time.h>                        //C/C++中的日期和时间头文件。用于需要时间方面的函数。
#include <vector>                        //vector在C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。
#include <math.h>                       
#include <stdlib.h>                     //标准库头文件  stdlib 头文件里包含了C、C  语言的最常用的系统函数
#include <algorithm>                   //lgorithm意为"算法",是C++的标准模版库(STL)中最重要的头文件之一，提供了大量基于迭代器的非成员模板函数。包含有sort()函数，此函数默认升序排列
#include <cstring>                     //字符串操作
#include <windows.h>                    
#include <fstream>                      //在C++中，对文件的操作是通过stream的子类fstream(file stream)来实现的


using namespace std;  
  
int position = 0;      //当前磁道位置  
int dis = 0;           //记录走过的长度
double average_distance = 0;  
 




//******************************************************************************** 
void request(vector<int>&m_vec,ofstream &outfile)   /*随机生成函数,请求服务序列，元素类型为vector<int>，m_vec为成员，ofstream &outfile定义文件输出流*/
{  
    cout<<"随机生成磁盘序列："<<endl;  
    int n = 0;  
    srand(time(NULL));     /*添加随机数种子, time(NULL)这个函数的返回值是作为srand函数的参数的！意思是以现在的系统时间作为随机数的种子来产生随机数！至于NULL这个参数。只有设置成NULL才能获得系统的时间！
                      srand函数是在调用rand（）这个函数之前使用的！rand（）是一个产生随机数的函数,srand是一个设置随机数种子的函数！通常这两个函数是一起使用的！来完成产生随机数的功能 */
    n = rand() % 20 + 1;     //函数获得1-20的一个随机数,即n的取值范围在1-20，注意文件#include<stdlib.h>
    int temp = 0;  
    for(int i=0;i<n;i++)
{  
        temp = rand() % 100;    //temp的取值范围是0-100
        m_vec.push_back(temp);   //将随机生成的temp数输入到vector里面，再从里面读取数据
        cout<<temp<<" ";           
        outfile<<temp<<endl;  /*outfile应该是定义的一个文件输出流（根据名字判断），就是输出数据到文件里。
                               infile应该是定义的一个文件输入流（根据名字判断），就是要从文件读取数据的。
                               .open 是要打开这个文件流对应的文件*/
    }  
    cout<<endl;  
    position = rand() % 100;  
    cout<<"当前磁道："<<position<<endl;  
}  
  




//*************************************************************************************
void compute_dis(vector<int>m_vec,int &dis,double &average_distance)             //计算平均距离函数
{  
    average_distance = (double)dis / (double)m_vec.size();  
}  
 
  


//************************************************************************************
void SSTF(vector<int>m_vec,int position)   //最短寻道时间算法
{  
    dis = 0;  
    average_distance = 0;  
    sort(m_vec.begin(),m_vec.end());    //从小到大排序，因为SSTF只能一个方向扫描
    int i = 0;  
    for(vector<int>::iterator it=m_vec.begin();it!=m_vec.end();it++)
/*vector<int>::iterator it=m_vec.begin()，声明一个迭代器，来访问vector容器，作用：遍历或者指向vector容器的元素,
使用迭代器访问元素iterator begin():返回向量头指针，指向vector的第一个元素，如果begin为end则是返回向量尾指针，
指向向量最后一个元素的下一个位置，*/


{  
        if(position >= *it)      //判断取出的序列是否大于当前磁道，先找到全部小于当前磁道的序列
            i++;  
    }  
    int count = 0;  //数据的数量，用于定义循环
    int left = i-1;  //i为下标
    int right = i;  
    while(count<m_vec.size())
{  
        if((left >=0 && abs(m_vec[right]-position) > abs(m_vec[left]-position)) || right>=m_vec.size()) 
//左边有数，以及与右边的数的距离大于与左边数的距离或者右边没有数的时候
{  
            dis += abs(m_vec[left]-position);      //计算与左边数的距离，取绝对值
            Sleep(500);                                 //休眠，500毫秒为它的参数，输出时此处停顿半秒
            cout<<"->"<<m_vec[left];               //输出
            position = m_vec[left];                //当前位置指针到输出的那个数
            left--;                                
        }  
        else{  
            dis += abs(m_vec[right]-position);      //否则计算右边的数的距离，取绝对值
            Sleep(500);  
            cout<<"->"<<m_vec[right];  
            position = m_vec[right];  
            right++;  
        }  
        count++;  
    }  
    compute_dis(m_vec,dis,average_distance);   //调用这个函数，得到磁头平均移动距离
} 


 
//**************************************************************************  
void SCAN(vector<int>m_vec,int position)    //电梯调度算法 ,先往左边比较，之后再往右回来
{   
    dis = 0;  
    average_distance = 0;  
    sort(m_vec.begin(),m_vec.end());    //从小到大排序  
    int i = 0;  
    for(vector<int>::iterator it=m_vec.begin();it!=m_vec.end();it++)  
/*vector<int>::iterator it=m_vec.begin()，声明一个迭代器，来访问vector容器，作用：遍历或者指向vector容器的元素,
使用迭代器访问元素iterator begin():返回向量头指针，指向vector的第一个元素，如果begin为end则是返回向量尾指针，
指向向量最后一个元素的下一个位置，*/


{  
        if(position >= *it)             //判断取出的序列是否大于当前磁道，先找到全部小于当前磁道的序列     
            i++;                    //找到position所在的磁道  
    }  
    int left = i - 1;            //先从外到内扫描  
    int right = i;  
    while(left >= 0)
{  
        dis += abs(position - m_vec[left]);  
        Sleep(500);  
        cout<<"->"<<m_vec[left];  
        position = m_vec[left];  
        left --;  
    }  
    while(right < m_vec.size())
{  
        dis += abs(position - m_vec[right]);  
        Sleep(500);  
        cout<<"->"<<m_vec[right];  
        position = m_vec[right];  
        right ++;  
    }  
    compute_dis(m_vec,dis,average_distance);   //调用这个函数，得到磁头平均移动距离
}  




//*******************************************************************************************  
void CSCAN(vector<int>m_vec,int position) //循环扫描算法      先往左扫描，然后从最右端回来扫描
{   
    dis = 0;  
    average_distance = 0;  
    sort(m_vec.begin(),m_vec.end());    //从小到大排序  
    int i = 0;  
    for(vector<int>::iterator it=m_vec.begin();it!=m_vec.end();it++)
    /*vector<int>::iterator it=m_vec.begin()，声明一个迭代器，来访问vector容器，作用：遍历或者指向vector容器的元素,
使用迭代器访问元素iterator begin():返回向量头指针，指向vector的第一个元素，如果begin为end则是返回向量尾指针，
指向向量最后一个元素的下一个位置，*/




{  
        if(position >= *it)           //判断取出的序列是否大于当前磁道，先找到全部小于当前磁道的序列  
            i++;      //找到position所在的磁道  
    }  
    int left = i - 1;   //先从外到内扫描  
    int right = i;  
    while(left >= 0)
{  
        dis += abs(position - m_vec[left]);  
        Sleep(500);  
        cout<<"->"<<m_vec[left];  
        position = m_vec[left];  
        left --;  
    }  
            //立即到最外侧的磁道  
    int len = m_vec.size()-1;  
    while(len >= right)
{  
        dis += abs(position - m_vec[len]);  
        Sleep(500);  
        cout<<"->"<<m_vec[len];  
        position = m_vec[len];  
        len --;  
    }  
    compute_dis(m_vec,dis,average_distance);  
}  
  




//****************************************************************************  
void print()
{  
    cout<<endl<<endl;  
    cout<<"经计算，磁头移动的总距离为:"<<dis<<endl;  
    cout<<"磁头平均移动距离:"<<average_distance<<endl;  
    cout<<endl<<endl;  
}  
  


//**********************************************************************************
int choose_algorithm(vector<int>m_vec)
{  
    cout<<endl<<endl;  
    cout<<"本实验可用的调度算法有以下5种："<<endl;    
cout<<"1.SSTF  2.SCAN  3.CSCAN  4.结束本序列的调度  5.结束程序"<<endl;  
    int choice = 0;  
    cout<<"选择："<<endl;  
    cin>>choice;  
    cout<<endl;  
    while(choice!=4 && choice!=5)
{  
        cout<<"磁盘请求的服务状况："<<endl;  
        cout<<position;  
        switch(choice)
{  
            case 1:  
                SSTF(m_vec,position);break;  
            case 2:  
                SCAN(m_vec,position);break;  
            case 3:  
                CSCAN(m_vec,position);break;   
            default:  
                cout<<"******非法输入!******"<<endl<<endl;break;   
        }   
        if(choice<=5 && choice>=1)   
            print();  
        cout<<"选择："<<endl;  
        cin>>choice;  
    }  
    if(choice == 5)  
        return 0;  
    else  
        cout<<endl<<endl;      //清空输出缓冲区，就是删除数据了
    return 1;  
}  
  


//**************************************************************************8
int main()
{  
    cout<<"---------------磁盘调度与管理-----------------"<<endl;  
    ofstream outfile;                       //将随机获取的数据输入到文件里面 
    outfile.open("data.txt");               //读出数据    
    while(1)
{  
        vector<int> vec;                    //定义容器的对象
        request(vec,outfile);                    //调用函数请求服务序列   
        int flag = choose_algorithm(vec);       //调用函数choose_algorithm(vec)，输出每次的选择情况
        if(flag == 0)  
            break;  
    }   
    outfile.close();  
    return 0;  
}