进程管理程序（完整版）1.0

/////////////////////////////////子函数1 创建进程函数
    #include <stdio.h>  //标准输入输出函数
#include <stdlib.h>  //标准库函数
#include <string>  //字符串处理函数
#include <ctype.h>  //字符操作函数
#include <conio.h>  //控制台输入输出函数，虽然不是标准头文件，但是大部分编译器都支持
#include <iostream>
using namespace std;
//________  //定义进程数量

/**
 *在文件开头声明函数原型，将函数定义放在main()函数后面
 *这是一个优雅的编程习惯
**/
int yanzheng(void);  //验证
void Menu(void);  //主界面
int Create(int);  //创建进程
int View(int);  //查看进程
int Swap(int,int);  //换出进程
int swapdg();//swap递归函数
int Kill(void);  //撤销进程
void Communicate(void);  //进程通信
void Redo(void);  //二级界面


struct PCB  //定义进程结构（PCB）
 {
  int ID;     //进程ID
  int jj;     //进程优先级
  int dx;     //进程大小
  string jx;  //进程信息
  bool hs;  //活动标识

 };       //结构体寄存器，用于中转其内在数据

struct PCB A[5],PCB_T;

int A_ID[5],PCB_s=0;//进程ID寄存器,用于累加当前系统中进程总数






int main()
{
if(yanzheng()==0)
 {
  return 0; // 主函数返回0 结束主函数;
 }

//用于验证密码
////////////////////////////////////////////////////////////


char key;
//用于判断用户对于子界面的选择

 int i,a,s=0;  
 //a用于判断用户输入的选择,s用于累加进程数量  进程总数 ,i用于作为循环变量


 //________;  //要进行的操作

 //显示程序菜单，执行各种操作
         while(1)
         {
          system("cls");

          //清屏

          Menu();

          //显示主菜单

          printf("请选择一个项目\n");

          scanf("%d",&a);

          //输入要执行的操作

          //刷新（清空）stdin缓冲区
           system("cls");
          //清屏

                      switch(a)     //a 用于用户的选择项
                      { 
                      case 1:       
                        printf(" 1.创建新进程\n");


                       while(1)
                       {
                           Create(0);       //Create();创建函数调用
                           PCB_s++;         //创建函数调用成功 PCB_s自增;
                           cout<<"是否继续创建进程Y/N";
                           cin>>key;
                                if(key!='Y')
                                {
                                    break;
                                }                               
                       }


                       printf("按任意键返回主菜单\n");
                       getch();

                       break; 
                      case 2:  


                       printf(" 2.查看某进程\n");

                       if(PCB_s!=0)     //PCB_s不能等于0进程总数,才能执行下列语句
                       {
                           View(PCB_s);  //View()函数调用;
                       }
                       else
                       {
                           cout<<"还未创建进程"<<endl;
                       }



                       printf("按任意键返回主菜单\n");
                       getch();

                       break; 
                    case 3:  //换出进程


                       printf(" 3.换出某进程\n");    
                           while(1)
                           {
                                if(PCB_s<2) //进程总数 小于2 没有交换进程的必要
                                {
                                    cout<<"当前未创建任何进程或者进程数小于2"<<endl;
                                        break;
                                }


                           Redo();  //输出进程号,用于提示用户输入需要

                            Swap(0,0);          //调用Swap();函数
                            cout<<"是否继续交换进程Y/N";
                           cin>>key;
                                if(key!='Y')
                                {
                                    break;
                                }   

                        system("cls");


                           }
                       printf("按任意键返回主菜单\n");
                       getch();

                       break;





                      case 4:  //撤销进程

                       printf("4.撤销某进程\n");

                       while(1)
                       {
                        Redo(); //输出进程号,用于提示用户输入需要

                        Kill();  //调用Kill();撤销进程函数

                        cout<<"是否继续撤销进程Y/N"<<endl;
                        cin>>key;
                        system("cls");
                        if(key!='Y')//继续撤销进程
                        {
                         break;

                        }
                    system("cls");

                       }



                       printf("按任意键返回主菜单\n");
                       getch();

                         break;

                       //Redo();


                      case 5:  //进程通信

                       printf("5.进程间通信\n");
                       while(1)
                       {
                                 if(PCB_s<2) //进程总数 小于2 没有交换进程的必要
                                {
                                    cout<<"当前未创建任何进程或者进程数小于2"<<endl;
                                        break;
                                }
                           Redo();  //输出进程号,用于提示用户输入需要

                        Communicate();  //调用进程通信函数

                        cout<<"是否继续进程通信Y/N"<<endl;
                        cin>>key;
                        if(key!='Y')//继续撤销进程
                        {
                         break;

                        }
                        system("cls");
                       }


                       printf("按任意键返回主菜单\n");
                       getch();

                       break;


                      case 6:  //退出系统
                       return 0;
                       //正常退出


                      default:
                       printf("没有相应的菜单，请从新选择...\n");
                       printf("按任意键返回主菜单\n");

                      }

                      //return 0;

                     }

         return 0;
        }











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

    int Create(int c)//c为进程下标
    {
         int j=0,i=0,CREATE_s=0;

    system("cls");

    if(PCB_s>5)
    {
        cout<<"您创建的进程超出范围(5)"<<endl;
        return 0;
    }
    ///////////////////////////////////////////////////////判断用户创建进程是否超出总和

        cout<<"ID号范围0-100，超出范围无效"<<endl;

         printf("请输入第%d创建进程的ID\n",PCB_s+1);
        scanf("%d",&A[PCB_s].ID);
        if(A[PCB_s].ID>=0&&A[PCB_s].ID<=100)
        {
         printf("请输入第%d进程的优先级(JJ)\n",PCB_s+1);
        scanf("%d",&A[PCB_s].jj);
         printf("请输入第%d进程的大小(DX)\n",PCB_s+1);
        scanf("%d",&A[PCB_s].dx);

////////////////////////////////////////////////////////
          printf("请输入第%d进程的信息(jx)\n",PCB_s+1);
        cin>>A[PCB_s].jx;
        }
        else
        {
            cout<<"您输入的进程ID号不在范围内"<<endl;
        }


        A[PCB_s].hs=true;
/*      
        for(i=0;i<c;i++)
        {
            if(A[c].ID==A[c--].ID)
            {cout<<"进程ID与之前进程冲突，请重新输入该进程ID"<<endl;

                printf("请输入第%d创建进程的ID\n",c+1);
                scanf("%d",&A[c].ID);
            }
        }

        CREATE_s++;
        A_ID[c]=A[c].ID;  //为进程ID寄存器赋值
        */
        system("cls");




        return 0;
    }
////////////////////////////////////////////////////////////////////////
    void Menu()
{
 printf("***********************************************\n");
 printf("*               进程演示系统                  *\n");
 printf("*       信管一班 201552070118 王同学          *\n");
 printf("***********************************************\n");
 printf("       1.创建新进程        2.查看某进程        \n");
 printf("       3.换出某进程        4.撤销某进程        \n");
 printf("       5.进程间通信        6.退出系统          \n");
 printf("***********************************************\n");
 printf("请选择（1～6）:");
}

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

int yanzheng()  ////////////////////验证码函数
{

 int a,i,j=3;

  for(i=0;i<3;i++)
 { 
   printf("请输入验证密码(6位)");
   scanf("%d",&a);

   if(a==123456) //验证密码是否正确
   {
    i=3;  //如果密码正确 ,改变循环变量，结束循环
   }
   else
   { 
    j--;  //j--提示用户输入密码错误次数
    printf("你输错了,还有%d次机会\n",j);

    if(j==0) 
    {
    return 0; //j==0 结束程序
    }
   }

 }
}


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

int View(int a)  //查看进程
{
    int i;
        printf("***********************************************\n");
        printf("共创建了%d个进程\n",a);
                    for(i=0;i<a;i++)
                {

                    printf("第%d个进程的ID为%d\n",i+1,A[i].ID);
                    printf("第%d个进程的优先级为%d\n",i+1,A[i].jj);
                    printf("第%d个进程的大小为%d\n",i+1,A[i].dx);
                    printf("第%d个进程的信息为",i+1);
                    cout<<A[i].jx<<endl;


                    printf("第%d个进程标示为",i+1);
                    if(A[i].hs==true)
                    {
                    cout<<"TRUE"<<endl;
                    }
        printf("***********************************************\n");        
                }


        printf("***********************************************\n");

    return 0;
}


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

int Swap(int n,int m) //换出进程  swap_c用于记录进程ID寄存器，swap_s用于记录当前创建进程总数
{
    int SWAP_A,SWAP_B,i,SWAP_SA=0,SWAP_SB=0,j; //SWAP_A用户输入A进程ID,SWAP_B用户输入B进程ID，i,j为循环变量,SWAP_SA与SWAP_SB是 针对 判断SWAP_A与SWAP_B时计数使用

    struct PCB *SWAP_A1,*SWAP_B1;  //*SWAP_A1/B1用途为交换结构体变量值时使用

    cout<<"请输入需要交换A进程的ID"<<endl;
    cin>>SWAP_A;
    cout<<"请输入需要交换B进程的ID"<<endl;
    cin>>SWAP_B;




    for(i=0;i<PCB_s;i++)
    {
    if(SWAP_A==A[i].ID)     //用于判断用户输入的SWAP_A是否存在
        {
            SWAP_A1=&A[i];  //若SWAP_A存在 则 SWAP_A1指向 目前的A[i]

            for(j=0;j<PCB_s;j++)    
            {
                if(SWAP_B==A[j].ID)//用于判断用户输入的SWAP_B是否存在
                {
                    SWAP_B1=&A[j];//存在 则 SWAP_B1指向 目前的A[j]

                    PCB_T=*SWAP_A1;
                    *SWAP_A1=*SWAP_B1;
                    *SWAP_B1=PCB_T;
                    cout<<"进程A与B交换成功"<<endl;        //交换成功
                }
                else
                {
                    SWAP_SB++;                  //SWAP_B不在范围内SWAP_SB自增
                    if(SWAP_SB==PCB_s)          //当SWAP_SB与PCB_s相等时 
                    {
                        cout<<"您输入的B进程不存在"<<endl;
                        break;
                    }
                }
            }
        }
        else
        {       SWAP_SA++;
                if(SWAP_SA==PCB_s)
                {
                    cout<<"您输入的A进程不存在"<<endl;
                    break;
                }
        }
    }



    return 0;
}


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

int Kill()  //撤销进程
{   
    int kill_id=0,i,kill_s=0;


    if(PCB_s==0) //PCB_s 如果等于0 则该操作无意义
    {
        cout<<"目前系统中不存在进程"<<endl;

        return 0;
    }

    else
    {   
        cout<<"请输入需要撤销进程的ID号"<<endl;
        cin>>kill_id;

        for(i=0;i<PCB_s;i++)
        {
            if(kill_id==A[i].ID)    //用于判断用户输入ID是否存在
            {

            A[i].hs=false;
            cout<<"撤销进程成功!"<<endl;

            return 0;
            }
            else        
            {
                kill_s++;
                if(kill_s==PCB_s)
                {
                    cout<<"您输入的进程不存在"<<endl;
                    break;
                }

            }
        }



    }
    PCB_s--;  //撤销一个进程后 PCB_s 自减；


    return 0;

}

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

void Communicate()  //进程通信
{
    int COM_A,COM_B,i,j,COM_SA=0,COM_SB=0;
    //COM_A/B为用户输入A/B进程的ID,i/j子函数循环变量,COM_SA/SB用于记录COM_A/B的判断次数



    cout<<"请输入需要操作A进程的ID"<<endl;
    cin>>COM_A;
    cout<<"请输入需要操作B进程的ID"<<endl;
    cin>>COM_B;

    for(i=0;i<PCB_s;i++)
    {
    if(COM_A==A[i].ID)
        {
            //COM_A1=&A[i];

            for(j=0;j<PCB_s;j++)
            {
                if(COM_B==A[j].ID)
                {
                    A[i].jx=A[i].jx+A[j].jx; //字符串之间可以直接用+连接符

                    cout<<"进程A与B通信成功"<<endl;
                }
                else
                {
                    COM_SB++;
                    if(COM_SB==PCB_s)
                    {
                        cout<<"您输入的B进程不存在"<<endl;
                        break;
                    }
                }
            }
        }
        else
        {       COM_SA++;
                if(COM_SA==PCB_s)
                {
                    cout<<"您输入的A进程不存在"<<endl;
                    break;
                }
        }
    }


}

void Redo() //二级界面
{
    int i;
    cout<<"当前进程id号如下"<<endl; //输出进程号,用于提示用户输入需要
        for(i=0;i<PCB_s;i++)
        {
            printf("第%d个进程的ID为%d\t",i+1,A[i].ID);
        }
}