信息系统分析与设计课程设计

一、课程设计的目的与意义

1、通过本课程设计的实践及其前后的准备与总结，复习、领会、巩固和运用信息系统分析与设计课堂上所学的系统开发方法和知识，初步掌握系统分析、系统设计、系统实现、系统维护的方法，特别是结构化分析、结构化设计、面向对象分析与面向对象设计。

2、了解软件工具与环境对于项目开发的重要性，并且重点深入掌握好一、两种较新或较流行的软件工具或计算机应用技术，为综合应用本专业所学习的多门课程知识创造实践机会。

二、课程设计内容及安排：

设计安排分五部分，每部分完成设计时间为一天，安排如下：

第一部分：系统分析部分

要求：

1. 调研欲开发的信息系统的用户需求和功能需求；

2. 根据调研结果画出主要的业务流程图、数据流图，编写数据字典。

实验目的：

1. 巩固掌握需求分析手段和方法；

2. 熟练使用Visio绘制业务流程图、数据流图；

3. 掌握数据字典的编写方法；

4. 提高学生遇到问题后分析问题和解决问题的能力。

第二部分：数据库及代码准备阶段

要求：

1. 根据调研方向，准备数据库资料，制作数据库文件。

2. 可以根据设计找相应软件完成，如SQL Server 2005、VS2005等。

3. 准备后续会使用的代码，如数据连接代码、数据调用代码等。

4. 要求每部分遇到的问题和处理方法也要做好记录。

实验目的：

1. 熟练数据库的理论知识和实际操作；

2. 深刻理解系统实施阶段的过程；

3. 提高学生逻辑思维能力和实际操作动手能力。

第三部分：系统实施及代码完善部分

要求：

1. 根据设计方向继续完善系统开发和代码调试。

2. 实施系统开发，完成系统设计。

3. 实现的效果抓图。

4. 将项目制作过程（代码、关键注释、效果抓图）保存好。

5. 要求每部分遇到的问题和处理方法也要做好记录。

实验目的：

1. 进一步了解系统开发的特点；

2. 掌握系统设计步骤并能具体实施；

3. 了解系统中代码含义和使用特点；

4. 增强学生对系统制作的学习兴趣；

5. 提高学生自学能力。

第四部分：测试及生成报告

要求：

1. 系统开发完成后进行简单测试；

2. 根据整个系统的完成过程生成系统报告；

3. 将整个过程抓图和文字描述记录到报告中；

4. 每部分遇到的问题和处理方法尽量记录下来。

实验目的：

1. 帮助学生更加熟练的理解系统开发设计的全过程；

2. 能够通过完成的项目得出有效的项目报告；

3. 提高学生业务处理能力。

第五部分：完善报告并打印

要求：

1. 根据给出的格式完善报告，将整个系统的完成过程关键部分记录到报告中；

2. 整个过程的抓图和文字描述也记录到报告中；

3. 每部分遇到的问题和处理方法尽量记录下来。

4. 打印并上交

实验目的：

1. 帮助学生更加熟练的理解系统开发设计的全过程；

2. 能够通过完成的项目得出有效的项目报告；

3. 提高学生业务处理能力。

三、总体要求：

1.将每部分的实验过程保存到课程设计报告中，整理综合设计报告，实训总结至少300字。

2.上交信息系统源码、设计报告的电子版和打印版。（按课程设计格式参考排版，见模板）。

3.上交时间：周五第六节。

四、课程设计评分标准

课程设计成绩由三部分构成：考勤分数（30%），态度分数（20%），报告分数（50%）。 课程设计时间为一周，分上下午分别签到，每次到课可得到3分，共30分，到课不满60%的学生没有课程设计成绩；实训时玩游戏，看视频及其他与实训无关的动作，将在实训态度分中分别扣除相应的分数。

编制人：贾会迎 李向红 编制时间：2014-5-10

 

第二篇：操作系统课程设计报告Linux二级文件系统设计

 

专    业：计算机科学与技术

学    号：********

姓    名：***

提交日期：20##-3-8

【设计目的】

（1）本实验的目的是通过一个简单多用户文件系统的设计，加深理解文件系统的内部功能和内部实现。

（2）结合数据结构、程序设计、计算机原理等课程的知识，设计一个二级文件系统，进一步理解操作系统。

（3）通过分对实际问题的分析、设计、编程实现，提高学生实际应用、编程的能力

【设计内容】

二级文件系统设计

【实验环境】

C++/VC++

【相关知识综述】

1.背景知识

（1）外存管理

文件系统是一个含有大量的文件及其属性，对文件进行操作、管理的软件，以及向用户提供使用文件的接口的一个集合。在逻辑上它的层次结构是这样的：

作为产品的操作系统有各自的文件系统。比如MS的WINDOWS系列使用的是FAT16、FAT32或NTFS的文件系统、LINUX使用的是EXT2、EXT3文件系统等等。

（2）linux的EXT2文件系统

linux使用一个叫虚拟文件系统的技术从而可以支持多达几十种的不同文件系统，而EXT2是linux自己的文件系统。它有几个重要的数据结构，一个是超级块，用来描述目录和文件在磁盘上的物理位置、文件大小和结构等信息。inode也是一个重要的数据结构。文件系统中的每个目录和文件均由一个inode描述。它包含：文件模式（类型和存取权限）、数据块位置等信息。

       一个文件系统除了重要的数据结构之外，还必须为用户提供有效的接口操作。比如EXT2提供的OPEN/CLOSE接口操作。

（3）用内存来模拟外存

真正的文件系统对外存进行管理，涉及到许多硬件、设备管理方面的底层技术，一方面这些技术不属于操作系统核心内容，一方面过多的内容不免造成实验者顾此失彼，所以这里推荐一种使用内存来模拟外存的方式，可以跳过这些硬件技术而直接把精力放在数据结构设计和操作算法设计上面。

    假定pInode是一个指向inode结构的指针，而且它已经放入的需要放入的数值了，现在需要将其写入到特定位置。可用如下代码：

……

fd=fopen(“filesystem”,”w+b”)；          //fd是FILE指针类型，w便是写方式，b表示二进制

fseek(fd, specific_area,SEEK_SET)；// fd是文件指针；specific_area为整形，

// 为需要入pInode的位置

fwrite(pInode, sizeof(inode), 1,fd)； // 写入pInode信息

2、原理算法

本文件系统采用两级目录，其中第一级对应于用户账号，第二级对应于用户帐号下的文件。另外，为了简便文件系统未考虑文件共享，文件系统安全以及管道文件与设备文件等特殊内容。

首先应确定文件系统的数据结构：主目录、子目录及活动文件等。主目录和子目录都以文件的形式存放于磁盘，这样便于查找和修改。

用户创建的文件，可以编号存储于磁盘上。如：file0,file1,file2…并以编号作为物理地址，在目录中进行登记。

【设计思路】

1、数据结构

#define MAXNAME 25  /*mfdname,ufdname,filename的最大长度*/

#define MAXCHILD 50 /*最大的子文件个数*/

#define MAX (MAXCHILD*MAXCHILD) /*物理地址计数fpaddrno的最大长度*/

typedef struct  /*结构体OSFILE(文件)*/

{

       int  fpaddr;                /*文件的物理地址号0,1,2...*/

       int  flength;               /*文件的长度*/

       int  fmode;   /*文件模式:0-Read Only;1-Write Only;2-Read and Write;3-protrcted;*/

       char fname[MAXNAME];     /*文件名*/

} OSFILE;

typedef struct     /*结构体OSUFD(用户目录)*/

{

       char ufdname[MAXNAME];   /*ufd的名字*/

       OSFILE ufdfile[MAXCHILD];   /*ufd自己的文件*/

}OSUFD;

typedef struct  /*结构体OSUFD'LOGIN(用户注册)*/

{

       char ufdname[MAXNAME];       /*ufd的名字*/

       char ufdpword[8];            /*ufd的密码*/

} OSUFD_LOGIN;

typedef struct     /*文件打开模式*/

{

       int ifopen;     /*打开情况:0-close,1-open*/

       int openmode;   /*读写模式0-read only,1-write only,2-read and write*/

}OSUFD_OPENMODE;

OSUFD *ufd[MAXCHILD];   /*ufd及ufd自己的文件（指针型）*/

OSUFD_LOGIN ufd_lp;     /*建立了一个OSUFD_LOGIN型的 ufd_lp*/

int ucount=0;  /*mfd的ufd的个数*/

int fcount[MAXCHILD];  /*ufd自己的文件个数*/

int loginsuc=0; /*是否成功登陆，1成功*/

char username[MAXNAME];  /*记录注册的用户名*/

char dirname[MAXNAME];/*记录文件当前的目录*/

int fpaddrno[MAX];  /*记录文件的物理地址num*/

OSUFD_OPENMODE ifopen[MAXCHILD][MAXCHILD]; /*创建一个OSUFD_OPENMODE型的数组用于记录每个文件的打开情况和读写模式*/

FILE *fp_mfd,*fp_ufd,*fp_file_p,*fp_file; /*定义FILE * 型的文件指针,用于读文件*/

2、主要的函数说明

       void LoginF()  /*用户注册登录*/

       void DirF()  /*显示文件系统的所有文件*/

       void CdF()  /*改变路径*/

       void CreateF()  /*创建文件*/

       void DeleteF() /*删除文件*/

       void ModifyFM() /*改变文件模式*/

       void OpenF()  /*打开文件*/

       void CloseF()  /*关闭文件*/

       void ReadF() /*读文件*/

       void WriteF() /*写文件*/

       void QuitF() /*退出文件系统*/

void clrscr()  /*清屏*/

void help(void) /*帮助*/

其他重要辅助函数：

     char *rtrim(char *str)  /*移除最右边的空格*/

     char *ltrim(char *str)  /*移除最左边的空格*/

void SetPANo(int RorW)  /*设置物理地址号(表示该地址号是否被用了0-未用,1-已用),RorW是0-read,1-write*/

void InputPW(char *password)  /*输入密码并使用'*'代替*/

int ExistD(char *dirname)  /*目录是否存在,存在返回第i个,不存在返回0*/

int ExistF(char *filename)  /*文件是否存在,返回返回第i个,不存在返回0*/

       int FindPANo()  /*找出要分配的物理地址号*/

int WriteF1()  /*创建文件中的写文件*/

3、程序流程设计：对于自己实现的4个功能：

（1）open():

（2）close():

（3）write():

（4）delete

【源程序清单】

#include "stdio.h"

#include "string.h"

#include "conio.h"

#include "stdlib.h"

#define MAXNAME 25  /*mfdname,ufdname,filename的最大长度*/

#define MAXCHILD 50 /*最大的子文件个数*/

#define MAX (MAXCHILD*MAXCHILD) /*物理地址计数fpaddrno的最大长度*/

typedef struct  /*结构体OSFILE(文件)*/

{

       int  fpaddr;                /*文件的物理地址号0,1,2...*/

       int  flength;               /*文件的长度*/

       int  fmode;   /*文件模式:0-Read Only;1-Write Only;2-Read and Write;3-protrcted;*/

       char fname[MAXNAME];        /*文件名*/

} OSFILE;

typedef struct     /*结构体OSUFD(用户目录)*/

{

       char ufdname[MAXNAME];   /*ufd的名字*/

       OSFILE ufdfile[MAXCHILD];   /*ufd自己的文件*/

}OSUFD;

typedef struct  /*结构体OSUFD'LOGIN(用户注册)*/

{

       char ufdname[MAXNAME];       /*ufd的名字*/

       char ufdpword[8];            /*ufd的密码*/

} OSUFD_LOGIN;

typedef struct     /*文件打开模式*/

{

       int ifopen;     /*ifopen:0-close,1-open*/

       int openmode;   /*0-read only,1-write only,2-read and write,3-protected*/

}OSUFD_OPENMODE;

OSUFD *ufd[MAXCHILD];   /*ufd及ufd自己的文件（指针型）*/

OSUFD_LOGIN ufd_lp;     /*建立了一个OSUFD_LOGIN型的 ufd_lp*/

int ucount=0;  /*mfd的ufd的个数*/

int fcount[MAXCHILD];  /*ufd自己的文件个数*/

int loginsuc=0; /*是否成功登陆*/

char username[MAXNAME];  /*记录注册的用户名*/

char dirname[MAXNAME];/*记录文件当前的目录*/

int fpaddrno[MAX];  /*记录文件的物理地址num*/

OSUFD_OPENMODE ifopen[MAXCHILD][MAXCHILD]; /*创建一个OSUFD_OPENMODE型的数组用于记录每个文件的状态（打开/关闭）*/

FILE *fp_mfd,*fp_ufd,*fp_file_p,*fp_file; /*定义FILE * 型的文件指针,用于读文件*/

void clrscr()  /*清屏*/

{

       system("cls");

}

void main()

{

       int i,choice1;  /*choice录选择的命令的号*/

       char choice[50];  /*选择表达式:dir,create,delete,open,delete,modify,read,write*/

       int choiceend=1;  /*是否选择结束*/

       char *rtrim(char *str);  /*移除最右边的空格*/

       char *ltrim(char *str);  /*移除最左边的空格*/

       void LoginF();  /*用户注册登录*/

       void DirF();  /*显示文件系统的所有文件*/

       void CdF();  /*改变路径*/

       void CreateF();  /*创建文件*/

       void DeleteF(); /*删除文件*/

       void ModifyFM(); /*改变文件模式*/

       void OpenF();  /*打开文件*/

       void CloseF();  /*关闭文件*/

       void ReadF(); /*读文件*/

       void WriteF(); /*写文件*/

       void QuitF(); /*退出文件系统*/

       void help();

       if((fp_mfd=fopen("c:\\osfile\\mfd","rb"))==NULL)   /*rb表示二进制读的方式打开,看他是否为空*/

       {

              fp_mfd=fopen("c:\\osfile\\mfd","wb");    /*rb表示二进制写的方式打开，没有相当于新创建一个mfd*/

              fclose(fp_mfd);

       }

      

       for(i=0;i<MAX;i++)

              fpaddrno[i]=0;   /*初始的时候将物理地址num设为0*/

       clrscr();   /*清屏*/

       LoginF();   /*用户注册登录*/

       clrscr();  

       if(loginsuc==1)  /*登陆成功*/

       {

              while (1)

              {                  

                     if (choiceend==1)  /*正确命令*/

                     {

                            printf("\n\nC:\\%s>",strupr(dirname));

                     }

                     else printf("Bad command or file name.\nC:\\%s>",strupr(username));  /*错误命令*/

                     gets(choice);

                     strcpy(choice,ltrim(rtrim(strlwr(choice))));   /*strlwr把输入的choice变为小写去掉空格后拷贝到choice*/

                     if (strcmp(choice,"dir")==0)   /*根据用户不同的命令输入获得不同的choice1值*/

                            choice1=1;

                     else if(strcmp(choice,"create")==0) choice1=2;

                     else if(strcmp(choice,"delete")==0) choice1=3;

                     else if(strcmp(choice,"attrib")==0)       choice1=4;

                     else if(strcmp(choice,"open")==0) choice1=5;

                     else if(strcmp(choice,"close")==0) choice1=6;

                     else if(strcmp(choice,"read")==0) choice1=7;

                     else if(strcmp(choice,"write")==0)choice1=8;

                     else if(strcmp(choice,"exit")==0)choice1=9;

                     else if(strcmp(choice,"cls")==0) choice1=10;

                     else if(strcmp(choice,"cd")==0) choice1=11;

                     else if(strcmp(choice,"help")==0) choice1=20;

                     else choice1=12;                  

                     switch(choice1)  /*根据不同的输入的命令对应相应的命令*/

                     {

                     case 1:     DirF();choiceend=1;break;

                     case 2:CreateF();choiceend=1;break;

                     case 3:DeleteF();choiceend=1;break;

                     case 4:ModifyFM();choiceend=1;break;

                     case 5:choiceend=1;OpenF();break;

                     case 6:choiceend=1;CloseF();break;

                     case 7:choiceend=1;ReadF(); break;

                     case 8:choiceend=1;WriteF();break;

                     case 9:printf("\nYou have exited this system.\n");QuitF();exit(0);break; /*退出系统*/

                     case 10:choiceend=1;clrscr();break;

                     case 11:CdF();choiceend=1;break;

                     case 20:help();choiceend=1;break;

                     default:choiceend=0;   /*其他错误命令则选择结束*/

                     }

              }

       }

       else printf("\nAccess denied.\n");  /*登陆不成功*/

}

void help(void) /*帮助*/

{    

       printf("\nThe Command List\n");

       printf("\nCd  Dir  Attrib  Create  write  Read  Open  Cls  Delete  Exit  Close\n");

}

char *rtrim(char *str)  /*移除右边的空格*/

{

       int n=strlen(str)-1;  /*n为串长-1*/

       while(n>=0)

       {

              if(*(str+n)!=' ')  /*不是空格了,则下一个置为/0结束符*/

              {

                     *(str+n+1)='\0';

                     break;

              }

              else /*是空格，继续往回退*/

                     n--;

       }

       if (n<0)  /*空串*/

              str[0]='\0';

       return str;

}

char *ltrim(char *str) /*移除左边的空格*/

{

       char *rtrim(char *str);

       strrev(str);   /*将str字符串反转*/

       rtrim(str);  /*移除右边的空格*/

       strrev(str); /*将str字符串再反转回来*/

       return str;

}

void LoginF()  /*用户注册登录*/

{    

       char loginame[MAXNAME],loginpw[9],logincpw[9],str[50]; 

       int i,j,flag=1;

       char a[25];

       int findout; /*注册用户是否存在 1为存在*/

       char *rtrim(char *str);  /*移除右边的空格*/

       char *ltrim(char *str);  /*移除左边的空格*/

       void InputPW(char *password);  /*输入密码并使用'*'代替*/

       void SetPANo(int RorW);  /*设置物理地址num*/

       while(1)

       {

              findout=0;       

              printf("\n\nLogin Name:");

              gets(loginame);

              ltrim(rtrim(loginame)); /*移除空格*/

              fp_mfd=fopen("c:\\osfile\\mfd","rb");   /*rb表示以二进制读的方式打开mfd*/

              for(i=0;fread(&ufd_lp,sizeof(OSUFD_LOGIN),1,fp_mfd)!=0;i++)  /*fread是从mfd中读,是否有用户可以读出,有4个参数分别是读出的存储缓冲区、读的大小、读出的最大数量、文件指针*/

              {    

                     if (strcmp(strupr(ufd_lp.ufdname),strupr(loginame))==0) /*检测转为大写的用户名是否存在*/

                     {

                            findout=1;  /*用户已存在*/

                            strcpy(logincpw,ufd_lp.ufdpword);    /*把已存在的密码ufd_lp.ufdpword拷贝到logincpw*/

                     }

              }

              fclose(fp_mfd); /*关闭文件*/

              if (findout==1)  /*用户已存在的情况*/

              {

                     printf("Login Password:");

                     InputPW(loginpw); /*输入密码并使用'*'代替*/

                     if (strcmp(loginpw,logincpw)==0)   /*如果用户输入的密码和已存在的相同*/  

                     {

                            strcpy(username,strupr(loginame));  /*把输入的用户名转成大写拷贝到username*/

                            strcpy(dirname,username);   /*把用户名拷贝到dirname*/

                            fp_mfd=fopen("c:\\osfile\\mfd","rb");  /*以二进制读的方式打开文件*/

                            for(j=0;fread(&ufd_lp,sizeof(OSUFD_LOGIN),1,fp_mfd)!=0;j++)/*fread是从mfd中读,是否有用户可以读出,有4个参数分别是读出的存储缓冲区、读的大小、读出的最大数量、文件指针*/

                            {

                                   strcpy(str,"c:\\osfile\\");

                                   strcat(str,ufd_lp.ufdname);  /*str为用户目录的路径*/

                                   ufd[j]=(OSUFD*)malloc(sizeof(OSUFD)); /*分配建立一个新的ufd*/

                                   strcpy(ufd[j]->ufdname,strupr(ufd_lp.ufdname));  /*ufdname写入ufd结构体的ufdname*/

                                   fp_ufd=fopen(str,"rb");  /*打开这个用户目录文件*/

                                   fcount[j]=0;  /*新创建的ufd中的文件的个数为0*/

                                   for(i=0;fread(&ufd[j]->ufdfile[i],sizeof(OSFILE),1,fp_ufd)!=0;i++,fcount[j]++)/*fread是从mfd中读,是否有用户可以读出,有4个参数分别是读出的存储缓冲区、读的大小、读出的最大数量、文件指针*/

                                   {                                                                /*j用户的文件个数也要+1*/

                                          ifopen[j][i].ifopen=0;       

                                          ifopen[j][i].openmode=4;   /*初始化所有的文件打开模式(不是文件自身的模式)*/

                                   }

                                   fclose(fp_ufd); /*关闭这个ufd*/

                            }

                            fclose(fp_mfd);  /*关闭mfd*/

                            ucount=j;   /*mfd中的ufd个数*/

                            SetPANo(0); /*设置物理地址号(表示该地址号是否被用了0-未用,1-已用)*/

                            printf("\n\nLogin successful! Welcome to this FileSystem\n\n");

                            loginsuc=1;  /*登陆成功*/

                            return;

                     }

                     else  /*输入密码不正确*/

                     {

                            printf("\n\n");

                            flag=1;  /*标记*/

                            while(flag)

                            {

                                   printf("Login Failed!  Password Error.  Try Again(Y/N):");

                                   gets(a);

                                   ltrim(rtrim(a));

                                   if (strcmp(strupr(a),"Y")==0)    /*判断是否重新输入*/

                                   {    

                                          loginsuc=0;flag=0;

                                   }

                                   else if(strcmp(strupr(a),"N")==0)

                                   {

                                          loginsuc=0;flag=0;return;

                                   }

                            }

                     }

              }

              else  /*用户不存在的情况*/

              {

                     printf("New Password(<=8):");

                     InputPW(loginpw); /*输入新密码并用'*'代替*/

                     printf("\nConfirm Password(<=8):");

                     InputPW(logincpw);  /*再次输入密码并用'*'代替*/

                     if (strcmp(loginpw,logincpw)==0)   /*两次输入的密码相同*/

                     {

                            strcpy(ufd_lp.ufdname,strupr(loginame));

                            strcpy(ufd_lp.ufdpword,loginpw);  /*把输入的用户名、密码记录到ufd_lp*/

                            fp_mfd=fopen("c:\\osfile\\mfd","ab");  /*以二进制接着写的方式打开mfd*/

                            fwrite(&ufd_lp,sizeof(OSUFD_LOGIN),1,fp_mfd);  /*把ufd_lp指向的内容接着写入到mfd中*/

                            fclose(fp_mfd);

                            strcpy(username,strupr(loginame));

                            strcpy(dirname,loginame);

                            strcpy(str,"c:\\osfile\\");

                            strcat(str,username); /*形成路径c:\\osfile\\用户名*/

                            if((fp_ufd=fopen(str,"rb"))==NULL)  /*以二进制读的方式打开,如果为空*/

                            {

                                   fp_ufd=fopen(str,"wb");  /*以二进制写的方式打开,即新创建用户名文件*/

                                   fclose(fp_ufd);

                            }

                            fp_mfd=fopen("c:\\osfile\\mfd","rb");  /*以读的方式打开mfd*/

                            for(j=0;fread(&ufd_lp,sizeof(OSUFD_LOGIN),1,fp_mfd)!=0;j++) /*fread是从mfd中读,是否有用户可以读出,有4个参数分别是读出的存储缓冲区、读的大小、读出的最大数量、文件指针*/

                            {

                                   strcpy(str,"c:\\osfile\\");

                                   strcat(str,ufd_lp.ufdname);    /*str为用户目录的路径*/

                                   ufd[j]=(OSUFD*)malloc(sizeof(OSUFD));  /*分配建立一个新的ufd*/

                                   strcpy(ufd[j]->ufdname,strupr(ufd_lp.ufdname));  /*ufdname写入ufd结构体的ufdname*/

                                   fp_ufd=fopen(str,"rb");

                                   for(i=0;fread(&ufd[j]->ufdfile[i],sizeof(OSFILE),1,fp_ufd)!=0;i++,fcount[j]++)/*fread是从mfd中读,是否有用户可以读出,有4个参数分别是读出的存储缓冲区、读的大小、读出的最大数量、文件指针*/

                                   {                                                                                                              /*j用户的文件个数也要+1*/

                                          ifopen[j][i].ifopen=0;       /*初始化所有的文件打开模式(不是文件自身的模式)*/

                                          ifopen[j][i].openmode=4;

                                   }

                                   fclose(fp_ufd);

                            }

                            fclose(fp_mfd);  /*关闭mfd*/

                            ucount=j;   /*mfd中的ufd个数*/

                            SetPANo(0); /*设置物理地址号(表示该地址号是否被用了0-未用,1-已用)*/

                            printf("\n\nLogin successful! Welcome to this FileSystem\n\n");

                            loginsuc=1;  /*登陆成功*/

                            return;

                     }

                     else  /*两次输入的密码不同*/

                     {

                            printf("\n\n");

                            flag=1;

                            while(flag)

                            {

                                   printf("Login Failed! Password Error. Try Again(Y/N):");

                                   gets(a);

                                   ltrim(rtrim(a));

                                   if (strcmp(strupr(a),"Y")==0)

                                   {

                                          loginsuc=0;

                                          flag=0;

                                   }

                                   else if(strcmp(strupr(a),"N")==0)

                                   {

                                          loginsuc=0;

                                          flag=0;

                                   }

                            }

                     }

              }

       }

}

void SetPANo(int RorW)  /*设置物理地址号(表示该地址号是否被用了0-未用,1-已用),RorW是0-read,1-write*/

{

       int i,j;

       if (RorW==0) /*以读的方式,已存在的用户*/

       {

              if((fp_file_p=fopen("c:\\osfile\\file\\file_p","rb"))==NULL) /*如果以二进制读的方式打开file_p文件找不到*/

              {

                     fp_file_p=fopen("c:\\osfile\\file\\file_p","wb");  /*以二进制写的方式打开,即创建一个file_p*/

                     fclose(fp_file_p);

              }

              fp_file_p=fopen("c:\\osfile\\file\\file_p","rb"); /*以二进制读的方式打开file_p*/

              for(i=0;fread(&j,sizeof(int),1,fp_file_p)!=0;i++) /*fread是从fp_file中读,是否有文件号可以读出,有4个参数分别是读出的存储缓冲区、读的大小、读出的最大数量、文件指针*/

                     fpaddrno[j]=1;    /*将第j个文件物理地址号置为1,已经用了*/

       }

       else /*以写的方式*/

       {

              fp_file_p=fopen("c:\\osfile\\file\\file_p","wb");  /*以二进制写的方式打开*/

              for(i=0;i<MAX;i++)

                     if (fpaddrno[i]==1)   /*第i个文件已存在*/

                            fwrite(&i,sizeof(int),1,fp_file_p);   /*记录物理地址号到fp_file*/

       }

       fclose(fp_file_p);

}

void InputPW(char *password)  /*输入密码并使用'*'代替*/

{

       int j; 

       for(j=0;j<=7;j++)  /*8位密码*/

       {

              password[j]=getch();   /*依次读入*/

              if ((int)(password[j])!=13)   /*!=回车*/

              {

                     if((int)(password[j])!=8)  /*!=退格*/

                            putchar('*');   

                     else   /*=退格*/

                     {

                            if (j>0)   

                            {

                                   j--;

                                   j--;

                                   putchar('\b');

                                   putchar(' ');

                                   putchar('\b');

                            }

                            else j--;

                     }

              }

              else   /*=回车,密码输入结束*/

              {

                     password[j]='\0';

                     break;

              }

       }

       password[j]='\0';

}

void DirF()  /*显示文件系统的所有文件*/

{

       int i,j,count=0;

       char sfmode[25],sfpaddr[25],str[25];

       int ExistD(char *dirname);  /*目录是否存在,存在-i个,不存在-0*/

       clrscr(); /*清屏*/

       if (strcmp(strupr(ltrim(rtrim(dirname))),"")!=0)  /*dirname不为空，显示的是当前用户的所有文件*/

       {

              printf("\n\nC:\\%s>dir\n",dirname);

              printf("\n%10s%15s%14s%8s%18s\n","FileName","FileAddress","FileLength","Type","FileMode");

              j=ExistD(dirname);   /*该目录是第几个目录*/

              for(i=0;i<fcount[j];i++)  

              {

                     if ((i%16==0)&&(i!=0))  /*满16个清屏*/

                     {

                            printf("\nPress any key to continue..");

                            getch();

                            clrscr();

                            printf("\n%10s%15s%14s%8s%18s\n","FileName","FileAddress","FileLength","Type","FileMode");

                     }

                     itoa(ufd[j]->ufdfile[i].fpaddr,str,10);  /*将整形转换为字符串型*/

                     strcpy(sfpaddr,"file");

                     strcat(sfpaddr,str);   /*连接成为物理地址 file x */

                     if (ufd[j]->ufdfile[i].fmode==0)

                            strcpy(sfmode,"Read Only");

                     else if(ufd[j]->ufdfile[i].fmode==1)

                            strcpy(sfmode,"Write Only");

                     else if(ufd[j]->ufdfile[i].fmode==2)

                            strcpy(sfmode,"Read And Write");

                     else

                            strcpy(sfmode,"Protect");

                     printf("%10s%15s%14d%8s%18s\n",ufd[j]->ufdfile[i].fname,sfpaddr,ufd[j]->ufdfile[i].flength,"<FILE>",sfmode);

              }

              printf("\n %3d file(s)\n",fcount[j]);

       }

       else /*dirname为空，显示的是上一层目录(主目录)的所有文件(各个用户文件夹)*/

       {

              printf("\n\nC:\\>dir\n");

              printf("\n%14s%18s%8s\n","DirName","OwnFileCount","Type");  /*包括3个项*/

              for(i=0;i<ucount;i++)

              {

                     if ((i%16==0)&&(i!=0))   /*满16个清屏*/

                     {

                            printf("\nPress any key to continue...");

                            getch();

                            clrscr();

                            printf("\n%14s%18s%8s\n","DirName","OwnFileCount","Type");

                     }

                     printf("%14s%18d%8s\n",ufd[i]->ufdname,fcount[i],"<UFD>");

                     count=count+fcount[i];      

              }

              printf("\n %3d dir(s),%5d file(s)\n",ucount,count);

       }

}

int ExistD(char *dirname)  /*目录是否存在,存在返回第i个,不存在返回-1*/

{

       int i;

       int exist=0;

       for(i=0;i<ucount;i++)

              if (strcmp(strupr(ufd[i]->ufdname),strupr(dirname))==0)

              {

                     exist=1;

                     break;

              }

              if (exist) return(i);  /*返回用户目录个数*/

              else return(-1);

}

void CdF() /*改变路径*/

{

       char dname[MAXNAME];

       char *rtrim(char *str);  /*移除左边的空格*/

       char *ltrim(char *str);  /*移除右边的空格*/

       int ExistD(char *filename);  /*目录是否存在,存在-i个,不存在-0*/

       printf("\nPlease input DirName (..-Previous dir; DirNAME-cd [DirNAME]):");

       gets(dname);

       ltrim(rtrim(dname));/*移除空格*/

       if (ExistD(dname)>=0)  /*如果存在用户目录,是>第0个目录*/

              strcpy(dirname,strupr(dname)); /*用户目录名拷贝到当前目录*/

       else if(strcmp(strupr(dname),"..")==0)  /*如果输入的dname是..*/

              strcpy(ltrim(rtrim(dirname)),""); /*将当前目录变为空*/

       else printf("\nError.\'%s\' does not exist.\n",dname); /*否则不存在*/

}

void CreateF() /*创建文件*/

{

       int fpaddrno,flag=1,i;

       char fname[MAXNAME],str[50],str1[50],a[25];

       char fmode[25];

       char *rtrim(char *str);  /*移除左边的空格*/

       char *ltrim(char *str);  /*移除右边的空格*/

       int FindPANo();  /*找出物理地址号*/

       int WriteF1(); /*写文件*/

       int ExistF(char *filename);  /*是否存在文件返回文件号(第几个),存在-i,不存在-0*/

       int ExistD(char *dirname);

       if (strcmp(strupr(dirname),strupr(username))!=0)  /*如果username和当前目录不同则不能创建*/

       {

              printf("\nError. You must create file in your own dir.\n");        

       }

       else  /*可以创建*/

       {

              printf("\nPlease input FileName:");

              gets(fname);  /*文件名*/

              ltrim(rtrim(fname));  /*去空格*/

              if (ExistF(fname)>=0)  /*文件号已存在*/

              {

                     printf("\nError. Name \'%s\' has already existed.\n",fname);

                     return;

              }

              else  /*文件号还未存在*/

              {

                     printf("Please input FileMode(0-Read Only, 1-Write Only, 2-Read and Write, 3-Protect):");

                     gets(fmode);  /*选择模式*/

                     ltrim(rtrim(fmode));

                     if((strcmp(fmode,"0")==0)||(strcmp(fmode,"1")==0)||(strcmp(fmode,"2")==0)||(strcmp(fmode,"3")==0))

                     {

                            fpaddrno=FindPANo();  /*找出新分配的物理地址号*/

                            if (fpaddrno>=0)  

                            {

                                   i=ExistD(username);   /*判断该用户是否存在，返回是第几个*/

                                   strcpy(ufd[i]->ufdfile[fcount[i]].fname,fname); /*将这个新的文件名写入ufd[i]->ufdfile[最后一个记录的下一个].fname*/

                                   ufd[i]->ufdfile[fcount[i]].fpaddr=fpaddrno; /*将新分配的物理地址号写入ufd[i]->ufdfile[最后一个记录的下一个].fpaddrno*/

                                   ufd[i]->ufdfile[fcount[i]].fmode=atoi(fmode);/*将新文件的模式写入ufd[i]->ufdfile[最后一个记录的下一个].fmode*/

                                   ifopen[i][fcount[i]].ifopen=0; /*初始化ifopen模式*/

                                   ifopen[i][fcount[i]].openmode=4;

                                   strcpy(str,"c:\\osfile\\file\\file");

                                   itoa(fpaddrno,str1,10); /*转为字符串*/

                                   strcat(str,str1); /*连接形成完整的路径*/

                                   fp_file=fopen(str,"wb");  /*以二进制写的形式打开以str为目录的文件,没有就创建，有就清空内容*/

                                   fclose(fp_file);

                                   fcount[i]++; /*第i个用户的文件数+1*/

                                   while(flag)

                                   {

                                          printf("Input text now(Y/N):");

                                          gets(a);

                                          ltrim(rtrim(a));

                                          ufd[i]->ufdfile[fcount[i]-1].flength=0;

                                          if(strcmp(strupr(a),"Y")==0)  /*输入文本*/

                                          {

                                                 fp_file=fopen(str,"wb+");

                                                 ufd[i]->ufdfile[fcount[i]-1].flength=WriteF1();  /*调用WriteF1()写文件,返回值是文件长度*/

                                                 flag=0;

                                          }

                                          else if(strcmp(strupr(a),"N")==0) /*不输入文本,结束*/

                                          {

                                                 flag=0;                                      

                                          }

                                   }

                                   printf("\n\'%s\' has been created successfully!\n",fname);

                            }

                            else /*无分配的地址号了（返回的-1）*/

                            {

                                   printf("\nFail!No Disk Space. Please format your disk.\n");      

                                   return;

                            }

                     }

                     else /*选择0-3外*/

                     {

                            printf("\nError. FileMode\'s Range is 0-3n");

                            return;

                     }

              }

       }

}

int ExistF(char *filename)  /*文件是否存在,返回返回第i个,不存在返回-1*/

{

       int i,j;

       int exist=0;

       int ExistD(char *dirname);

       j=ExistD(dirname);/*第j个用户*/

       for(i=0;i<fcount[j];i++)

              if (strcmp(strupr(ufd[j]->ufdfile[i].fname),strupr(filename))==0)

              {

                     exist=1;

                     break;

              }

              if (exist)

                     return(i);

              else

                     return(-1);

}

int FindPANo()  /*找出要分配的物理地址号*/

{

       int i;

       for(i=0;i<MAX;i++)

              if (fpaddrno[i]==0)  

              {

                     fpaddrno[i]=1;  /*第i个未用,将第i个的物理地址num设为1*/

                     break;

              }

              if (i<MAX)

                     return(i);  /*返回标号*/

              else

                     return(-1);

}

int WriteF1()  /*创建文件中的写文件*/

{

       int length=0;

       char c;

       printf("Please input text(\'#\' stands for end):\n");

       while((c=getchar())!='#')

       {

              fprintf(fp_file,"%c",c);

              if (c!='\n')

                     length++;

       }

       getchar(); 

       fprintf(fp_file,"\n");

       fclose(fp_file);

       return(length); /*文件长度*/

}

void ModifyFM() /*改变文件模式*/

{

       char fname[MAXNAME],str[50];

       int i,k;

       char fmode[25];

       char *rtrim(char *str); 

       char *ltrim(char *str);  /*删除空格*/

       void InputPW(char *password);  /*输入密码并用 * 代替*/

       void SetPANo(int RorW);  /*设置物理地址num*/

       int ExistF(char *filename);  /*文件名是否存在,Exist-i,Not Exist-0*/

       int ExistD(char *dirname);

       if (strcmp(strupr(dirname),strupr(username))!=0) /*用户名和当前目录不同*/

       {

              printf("\nError.You can only modify filemode in yourself dir.\n");          

       }

       else /*用户名和当前目录相同*/

       {

              printf("\nPlease input FileName:");

              gets(fname);

              ltrim(rtrim(fname));

              i=ExistF(fname);  /*第几个文件*/

              if (i>=0)  /*该文件存在*/

              {

                     k=ExistD(username); /*第几个用户号*/

                     if(ifopen[k][i].ifopen==1)  /*如果该文件是打开的*/

                     {

                            printf("\nError.\'%s\' is in open status. Close it before modify.\n",fname);

                     }

                     else  /*是关闭的*/

                     {

                            if(ufd[k]->ufdfile[i].fmode==0)  /*现存的文件模式*/

                                   strcpy(str,"read only");   

                            else if(ufd[k]->ufdfile[i].fmode==1)

                                   strcpy(str,"write only");

                            else if(ufd[k]->ufdfile[i].fmode==2)

                                   strcpy(str,"read and write"); 

                            else strcpy(str,"Protect");

                            printf("\'%s\' filemode is %s.\n",fname,strupr(str)); /*显示出现存的文件模式*/

                            printf("Modify to(0-read only,1-write only,2-read and write,3-Protect):");

                            gets(fmode); 

                            ltrim(rtrim(fmode));

                            if(strcmp(fmode,"0")==0) /*改为read only*/

                            {

                                   ufd[k]->ufdfile[i].fmode=0;

                                   printf("\n\'%s\' has been modified to READ ONLY mode successfully.\n",fname);                        

                            }

                            else if(strcmp(fmode,"1")==0)/*改为write only*/

                            {

                                   ufd[k]->ufdfile[i].fmode=1;

                                   printf("\n\'%s\' has been modified to WRITE ONLY mode successfully.\n",fname);        

                            }

                            else if(strcmp(fmode,"2")==0)/*改为read and write*/

                            {

                                   ufd[k]->ufdfile[i].fmode=2;

                                   printf("\n\'%s\' has been modified to READ AND WRITE mode successfully.\n",fname);              

                            }                         

                            else if(strcmp(fmode,"3")==0) /*改为Protect*/

                            {

                                   ufd[k]->ufdfile[i].fmode=3;

                                   printf("\n\'%s\' has been modified to PROTECT mode successfully.\n",fname);              

                            }                                

                            else

                            {

                                   printf("\nError.\'%s\' is not modified.\n",fname);                            

                            }

                     }

              }

              else /*该文件不存在*/

              {

                     printf("\nError. \'%s\' dose not exist.\n",fname);               

              }

       }

}

void ReadF() /*读文件*/

{

       int i,k,n=0;

       char fname[MAXNAME];

       char str[255],str1[255],c;

       char *rtrim(char *str);   

       char *ltrim(char *str);  /*移除空格*/

       int ExistF(char *filename);  /*文件名是否存在,Exist-i,Not Exist-0*/

       int ExistD(char *dirname);

       if (strcmp(strupr(ltrim(rtrim(dirname))),"")==0)  /*如果当前目录为空（主目录）*/

       {

              printf("\nError.Please convert to ufd dir before read.\n"); /*必须转到用户目录下*/

              return;

       }

       printf("\nCaution:Open file first\n\n");

       printf("Opened File(s) List:\n");

       k=ExistD(dirname);   /*第几个用户*/

       for(i=0;i<fcount[k];i++)   /*第k个用户有多少个文件*/

       {

              if (ifopen[k][i].ifopen==1)  /*如果文件已打开*/

                     if ((ifopen[k][i].openmode==0) ||(ifopen[k][i].openmode==2)) /*可以读*/

                     {

                            printf("%15s",ufd[k]->ufdfile[i].fname);  /*输出这个已打开的可读的文件名*/

                            n++;

                     }

                     if((n%4==0)&&(n!=0))

                            printf("\n");  /*4个换行*/

       }

       printf("\n%d files openned.\n",n);

       if (n==0)   /*无打开的文件,返回*/

              return;

       if (n!=0)  /*有打开的文件*/

       {

              printf("\nPlease input FileName:");

              gets(fname);

              ltrim(rtrim(fname));

              i=ExistF(fname);  /*第几个文件号*/

              if(i>=0) /*文件存在*/

              {

                     if(ifopen[k][i].ifopen==1)  /*已打开*/

                     {

                            if((ifopen[k][i].openmode==0) ||(ifopen[k][i].openmode==2))  /*可读*/

                            {

                                   itoa(ufd[k]->ufdfile[i].fpaddr,str,10); /*文件号整形转为字符串*/

                                   strcpy(str1,"file");

                                   strcat(str1,str);

                                   strcpy(str,"c:\\osfile\\file\\");

                                   strcat(str,str1); /*str形成路径c:\\osfile\\file\\filex*/

                                   fp_file=fopen(str,"rb"); /*以二进制读的方式打开filex文件*/

                                   fseek(fp_file,0,0);  /*指针移到0*/

                                   printf("\nThe text is:\n\n");

                                   printf("   ");

                                   while(fscanf(fp_file,"%c",&c)!=EOF)  /*从file中一个一个字符读出来*/

                                          if (c=='\n')  /*读出的是回车*/

                                                 printf("\n   "); /*输出回车*/

                                          else   /*读出的是其他*/

                                                 printf("%c",c);  /*输出其他字符*/

                                          printf("\n\n%d Length.\n",ufd[k]->ufdfile[i].flength); /*显示出该文件长度*/

                                          fclose(fp_file);                                         

                            }

                            else /*不可读*/

                            {

                                   printf("\nError.\'%s\' has been opened with WRITE ONLY mode. It isn\'t read.\n",fname);                                 

                            }

                     }

                     else /*未打开*/

                     {

                            printf("\nError.\'%s\' is in closing status. Please open it before read\n",fname);                     

                     }

              }

              else /*文件不存在*/

              {

                     printf("\nError. \'%s\' does not exist.\n",fname);

                    

              }

       }

}

void QuitF() /*退出文件系统*/

{

       int i,j;

       char str[50];

       void SetPANo(int RorW);   

       SetPANo(1);  /*设置物理地址号(表示该地址号是否被用了0-未用,1-已用),RorW是0-read,1-write*/

       if (fp_mfd!=NULL)

              fclose(fp_mfd);

       if (fp_ufd!=NULL)

              fclose(fp_ufd);

       if (fp_file!=NULL)     

              fclose(fp_file);   /*关闭文件*/

       for(j=0;j<ucount;j++) 

       {

              strcpy(str,"c:\\osfile\\");

              strcat(str,ufd[j]->ufdname);

              ltrim(rtrim(str));  /*去除空格*/

              fp_ufd=fopen(str,"wb"); /*二进制写的方式打开ufd文件,相当于清空内容*/

              fclose(fp_ufd);   /*关闭*/

              fp_ufd=fopen(str,"ab"); /*二进制接着写的方式打开ufd文件*/

              for(i=0;i<fcount[j];i++)

                     fwrite(&ufd[j]->ufdfile[i],sizeof(OSFILE),1,fp_ufd);   /*将文件信息写入ufd*/

              fclose(fp_ufd);

       }

}

void OpenF() /*打开文件*/

{

       char fname[MAXNAME];

       int i,k;

       if (strcmp(strupr(dirname),strupr(username))!=0) /*用户名和当前目录不同*/

       {

              printf("\nError! You can only open file in yourself dir.\n");             

       }

       else /*用户名和当前目录相同了*/

       {

              printf("\nPlease input FileName:");

              gets(fname);

              ltrim(rtrim(fname));   /*去除空格*/

              i=ExistF(fname); /*文件是否存在并返回第几个文件号*/

              if (i>=0) /*文件存在*/

              {    

                     k=ExistD(username);   /*根据用户名确定用户号*/

                     if(ifopen[k][i].ifopen==1)   /*该文件已经打开*/

                     {

                            printf("\nError. file \'%s\' had been opened, it can not be opened again.\n",fname);        

                     }

                     else   /*该文件还未打开*/

                     {

                            if((ufd[k]->ufdfile[i].fmode==0)||(ufd[k]->ufdfile[i].fmode==1)||(ufd[k]->ufdfile[i].fmode==2)) /*该文件的属性是可以被打开的*/

                            {

                                   ifopen[k][i].ifopen=1;   /*打开,将ifopen设为1*/

                                   ifopen[k][i].openmode=(ufd[k]->ufdfile[i].fmode);  /*将ifopen.openmode设为该文件的模式*/

                                   printf("\'%s\' has been opened successfully!",fname);

                            }

                            else     /*保护模式的文件不能被打开*/

                                   printf("\n\'%s\' is a protected file, it can not be opened.",fname);                    

                     }

              }    

              else /*文件不存在*/

              {

                     printf("\nError.\'%s\' dose not exist.\n",fname);                

              }

       }

}

void CloseF() /*关闭文件*/

{

       char fname[MAXNAME];

       int i,k;

       if (strcmp(strupr(dirname),strupr(username))!=0) /*用户名和当前目录不同*/

       {

              printf("\nError.You can only modify filemode in yourself dir.\n");          

       }

       else /*用户名和当前目录相同了*/

       {

              printf("\nPlease input FileName:");

              gets(fname);

              ltrim(rtrim(fname)); /*去除空格*/

              i=ExistF(fname);   /*文件是否存在并返回第几个文件号*/

              if (i>=0)   /*文件存在*/

              {

                     k=ExistD(username);    /*根据用户名确定用户号*/

                     if(ifopen[k][i].ifopen==0)   /*该文件未打开*/

                     {

                            printf("\nError. \'%s\' has been closed. you can not close it again.\n",fname);                        

                     }

                     else  /*该文件已打开*/

                     {

                            ifopen[k][i].ifopen=0;   /*关闭,置为0*/

                            ifopen[k][i].openmode=4; /*修改打开模式为初始的打开模式*/

                            printf("\'%s\' has been closed successfully!",fname);   

                     }

              }    

              else  /*文件不存在*/

              {

                     printf("\nError. \'%s\' dose not exist.\n",fname);               

              }

       }

}

void DeleteF() /*删除文件*/

{

       char fname[MAXNAME];

       int i,k,x;

       char str[255],str1[255];

       if (strcmp(strupr(dirname),strupr(username))!=0) /*用户名和当前目录不同*/

       {

              printf("\nError. You can only delete file in yourself dir.\n");

       }

       else  /*用户名和当前目录相同了*/

       {

              printf("\nPlease input FileName:");

              gets(fname);

              ltrim(rtrim(fname)); /*去除空格*/

              i=ExistF(fname);    /*文件是否存在并返回第几个文件号*/

              if (i>=0)  /*文件存在*/

              {    

                     k=ExistD(username);  /*根据用户名确定用户号*/

                     if(ufd[k]->ufdfile[i].fmode==3) /*该文件的属性是protect的*/

                     {

                            printf("\n\'%s\' is a protected file, it can not be deleted.",fname);

                     }

                     else /*该文件的属性不是protect的可以删除*/

                     {

                            if(ifopen[k][i].ifopen==1) /*该文件已打开不能删*/

                                   printf("\n\'%s\' has been opened, it can not be deleted.",fname);

                            else /*关闭的可以删*/

                            {

                                   itoa(ufd[k]->ufdfile[i].fpaddr,str,10);  /*itoa是将整型转换为字符串,存入str中,10代表10进制*/

                                   strcpy(str1,"file");   

                                   strcat(str1,str);     /*str连到str1后*/

                                   strcpy(str,"c:\\osfile\\file\\");   /*文件目录拷到str中*/

                                   strcat(str,str1);   /*把str1连入,最后str为c:\\osfile\\file\\filex*/

                                   x =_unlink(str);  /*删除路径为str的文件,删除成功返回0,否则返回-1*/

                                   fpaddrno[ufd[k]->ufdfile[i].fpaddr]=0;/*把删除后的地址号置为未用*/                                                                             

                                   for(i;i<(fcount[k]-1);i++)

                                   {

                                          ufd[k]->ufdfile[i]=ufd[k]->ufdfile[i+1];   /*删除的文件后面的文件向前移*/

                                   }

                                   fcount[k]--;  /*删除后第k个用户的文件数减1*/

                                   printf("\'%s\' has been deleted successfully!",fname);                                                                                                  

                            }

                     }

              }

              else /*文件不存在*/

              {

                     printf("\nError. \'%s\' dose not exist.\n",fname);               

              }

       }

}

void WriteF() /*写文件*/

{

       char str[50],str1[50];

       int i,k,n=0;

       char fname[MAXNAME];

       char *rtrim(char *str);   

       char *ltrim(char *str);  /*移除空格*/

       int ExistF(char *filename);  /*文件名是否存在返回文件号,Exist-i,Not Exist-0*/

       int ExistD(char *dirname);

       if (strcmp(strupr(ltrim(rtrim(dirname))),"")==0)  /*如果当前目录为空（主目录）*/

       {

              printf("\nError.Please convert to ufd dir before write.\n"); /*必须转到用户目录下*/

              return;

       }    

       else

       {

              printf("\nCaution:Open file first\n"); 

              printf("Opened File(s) List:\n");

              k=ExistD(dirname);    /*第几个用户*/    

              for(i=0;i<fcount[k];i++)   /*第k个用户有多少个文件*/

              {

                     if (ifopen[k][i].ifopen==1)  /*如果文件已打开*/

                            if ((ifopen[k][i].openmode==0) ||(ifopen[k][i].openmode==2)) /*可以读*/

                            {

                                   printf("%15s",ufd[k]->ufdfile[i].fname);  /*输出这个已打开的可读的文件名*/

                                   n++;

                            }

                            if((n%4==0)&&(n!=0))

                                   printf("\n");  /*4个换行*/

              }

              printf("\n%d files openned.\n",n);

              if (n==0)   /*无打开的文件,返回*/

                     return;

              if(n!=0) /*有打开的文件*/

              {

                     printf("\nPlease input FileName:");

                     gets(fname);

                     ltrim(rtrim(fname)); /*移除空格*/

                     i=ExistF(fname); /*第几个文件号*/

                     if(i>=0) /*文件存在*/

                     {

                            if(ifopen[k][i].ifopen==1)  /*已打开*/

                            {

                                   if((ifopen[k][i].openmode==1) ||(ifopen[k][i].openmode==2))  /*属性可以写*/

                                   {

                                         

                                          itoa(ufd[k]->ufdfile[i].fpaddr,str,10);  /*将文件号整形转为字符串*/

                                          strcpy(str1,"file");

                                          strcat(str1,str);

                                          strcpy(str,"c:\\osfile\\file\\"); 

                                          strcat(str,str1);  /*str形成路径c:\\osfile\\file\\filex*/                     

                                          fp_file=fopen(str,"wb+");   /*以写二进制方式(并且先清除已有的内容)打开filex文件*/

                                          int length=0; 

                                          char c;

                                          printf("Please input text(\'#\' stands for end):\n");

                                          while((c=getchar())!='#')

                                          {

                                                 fprintf(fp_file,"%c",c);  /*写入字符到文件filex中*/

                                                 if (c!='\n')

                                                        length++;   

                                          }

                                          getchar();/*接收回车*/

                                          fprintf(fp_file,"\n");  

                                          fclose(fp_file); 

                                          printf("write successfully!\n");

                                          ufd[k]->ufdfile[i].flength=length;   /*记录文件长度*/

                                         

                                   }

                                   else  /*属性不可以写*/

                                   {

                                          printf("\nError.\'%s\' has been opened with read ONLY mode. It isn\'t write.\n",fname);

                                   }

                            }

                            else /*文件未打开*/

                            {

                                   printf("\nError.\'%s\' is in closing status. Please open it before write\n",fname);

                            }

                     }

                     else /*文件不存在*/

                     {

                            printf("\nError. \'%s\' does not exist.\n",fname);

                     }

              }

       }

}

【测试结果】

登录系统，并创建用户

创建文件并退出程序

重新登录后浏览列表，打开文件，阅读文件并重写文件

重写后阅读并关闭

浏览文件并删除文件

删除后再次浏览文件

【设计总结】

为了完成这次的课程设计，我复习了大一学期学的C语言的文件部分，因为那里我一直没有掌握好，遇到问题查阅MSDN帮助文档，并且为了方便阅读，我把老师之前给的英文注释改成了中文注释，自己还添加了很多注释。通过这次的学习后，让我对文件的操作更加熟练了，并且对Linux有了初步的了解。在老师和同学的帮助下，我完成了这次的任务，并锻炼了自己的思考能力，让我有了很大的收获。

【参考文献】

1、  C程序设计（第四版）谭浩强著 清华大学出版社

2、  MSDN帮助文档