操作系统 模拟文件管理 大作业.docx

操作系统 模拟文件管理 大作业.docx

《操作系统 模拟文件管理 大作业.docx》由会员分享，可在线阅读，更多相关《操作系统 模拟文件管理 大作业.docx（29页珍藏版）》请在冰豆网上搜索。

操作系统模拟文件管理大作业

课程设计二：

模拟文件管理

一．设计目的

（1）建立一个简单的模拟文件管理系统。

（2）理解用户界面和操作命令在操作系统中的作用。

二．设计要求

需要实现一个命令行操作界面，包含如下命令：

1.创建文件

功能：

创立一个指定名字的新文件，即在目录中增加一项，不考虑文件内容，但必须能输入文件长度。

2.删除文件

功能：

删除指定的文件

3.创建目录

功能：

在当前路径下创建指定的目录。

4.删除目录

功能：

删除当前目录下的指定目录，如果该目录为空，则可删除，否则应提示是否作删除，删除操作将该目录下的全部文件和子目录都删除。

5.改变目录

功能：

工作目录转移到指定的目录下，只要求完成改变到当前目录的某一个子目录下的功能，不要求实现相对目录以及绝对目录。

6.显示目录

功能：

显示全部目录以及文件，输出时要求先输出接近根的目录，再输出子目录。

对于重名（创建时），文件不存在（删除时），目录不存在（改变目录时）等错误情况，程序应该作出相应处理并给出错误信息。

界面的提示符为#，提示的命令以及调试的方法应和前面的要求一致，可以自己设计更多的命令或者附加功能。

三．环境

本实验是在windowsxp+vc6.0环境下实现的，利用windowsSDK提供的系统接口（API）完成程序功能。

在windowsxp下安装好VC后进行，VC是一个集成开发环境，其中包含了windowsSDK所有工具，所以就不用单独在安装SDK了，程序中所用的API是操作系统提供的用来进行应用程序设计的系统功能接口。

要使用这些API，需要包含对这些函数进行说明的SDK头文件，最常见的就是windows.h。

一些特殊的API调用还需要包含其他的头文件。

四．步骤

1.打开VC，选择菜单项File->New，选择Project选项卡并建立一个名为filesys的win32consoleapplication工程。

2.在工程中创建原文件filesys.cpp：

选择菜单项Project->AddtoProject->File，此时将打开一个新窗口，在其中输入想要创建的文件名字，这里是filesys.cpp，在其中编辑好原文件并保存。

3.通过调用菜单项Build->Rebuildall进行编译连接，可以在指定的工程目录下得到debug->filesys.exe程序，可以在控制台进入该debug目录运行程序了。

五．源代码程序：

#include

#include

#include

#include

#include

#defineFILENAME_LEN21

#defineINPUT_LEN81

#defineCOMMAND_LEN11

usingnamespacestd;

//结点结构

structFileNode

{

charfilename[FILENAME_LEN];//文件名/目录名

intisdir;//目录文件识别标志

inti_nlink;//文件的链接数

intadr;//文件的地址

structFileNode*parent,*child;//指向父亲的指针和指向左孩子的指针

structFileNode*sibling_prev,*sibling_next;//指向前一个兄弟的指针和指向

//后一个兄弟的指针.

};

voidInit（）;//初始化文件树

intParseCommand（）;//接受输入的命令并把其分解成操作名和路径文件名

voidExecuteCommand（）;//执行命令

intcdComd（）;//处理cd命令

intcreatComd（）;//处理creat命令

intdelComd（）;//处理del命令

intdirComd（）;//处理dir命令

intmdComd（）;//处理md命令

intrdComd（）;

intFindPath（char*ph）;//寻找参数ph所指向的路径

intFindFilename（charPara2[]）;//从参数Para2中找到要建立或删除的文件、目录名，并把指针只想其父亲结点

structFileNode*CreateFileNode（charfilename[],intisdir,inti_nlink）;//创建结点

intGetInput（char*buffer,unsignedintbuffer_len）;//获取输入

intCheckCommand（）;//命令检查

intGetDir（intbegin,char*path,char*curDir）;//获取路径

voidTrim（char*str）;

structFileNode*cp,*tp,*root;

charpath[INPUT_LEN-COMMAND_LEN];//记录当前走过的路径

charPara1[COMMAND_LEN],Para2[INPUT_LEN-COMMAND_LEN];

charcurpath[INPUT_LEN-COMMAND_LEN],tmppath[INPUT_LEN-COMMAND_LEN];

charfilename[FILENAME_LEN],tmp;

unsignedinti,j;//inti,j;

//主函数

intmain（）

{

printf（"模拟文件管理系统\n"）;

printf（"\ncd改变目录;creat创建文件;del删除文件;\n"）;

printf（"dir显示目录;md创建目录;rd删除目录;exit退出.\n"）;

printf（"\n--------------------------------------------------------------------------------\n"）;

Init（）;//初始化文件树

while

（1）

{//printf（"#"）;

if（ParseCommand（））//分解命令

ExecuteCommand（）;//执行命令

}

return0;

}

//执行命令子函数

voidExecuteCommand（）

{

intsign;

//根据参数Para1调用相应的功能处理模块

if（strcmp（Para1,"cd"）==0）

sign=cdComd（）;//cd命令

elseif（strcmp（Para1,"creat"）==0）

sign=creatComd（）;//edit命令

elseif（strcmp（Para1,"md"）==0）

sign=mdComd（）;

elseif（strcmp（Para1,"del"）==0）

sign=delComd（）;//del命令

elseif（strcmp（Para1,"rd"）==0）

sign=rdComd（）;

elseif（strcmp（Para1,"dir"）==0）

sign=dirComd（）;//dir命令

elseif（strcmp（Para1,"exit"）==0）

exit（0）;//exit命令

else

printf（"命令错误,请重试\n"）;//命令输入不正确，报错

}

//创建结点

structFileNode*CreateFileNode（charfilename[],intisdir,inti_nlink）

{

//申请结点空间

structFileNode*node=（structFileNode*）malloc（sizeof（structFileNode））;

//相应内容赋初值

strcpy（node->filename,filename）;

node->isdir=isdir;

node->i_nlink=i_nlink;

node->parent=NULL;

node->child=NULL;

node->sibling_prev=NULL;

node->sibling_next=NULL;

returnnode;

}

//初始化文件树

voidInit（）

{

structFileNode*dir1Node,*dir2Node,

*file1Node,*etcNode,*libNode,*userNode,

*binNode2,*liuNode,*sunNode,*ftiNode;

strcpy（path,"/"）;//根目录写入当前路径

//创建文件树的结点

dir1Node=CreateFileNode（"dir1",1,0）;

dir2Node=CreateFileNode（"dir2",1,0）;

file1Node=CreateFileNode（"file1",0,0）;

etcNode=CreateFileNode（"etc",1,0）;

libNode=CreateFileNode（"lib",1,0）;

userNode=CreateFileNode（"user",1,0）;

binNode2=CreateFileNode（"bin",1,0）;

liuNode=CreateFileNode（"liu",1,0）;

sunNode=CreateFileNode（"sun",1,0）;

ftiNode=CreateFileNode（"fti",1,0）;

cp=tp=root=CreateFileNode（"/",1,0）;

//结点相应内容赋值

root->parent=NULL;

root->child=dir1Node;

root->sibling_prev=root->sibling_next=NULL;

dir1Node->parent=root;

dir1Node->child=NULL;

dir1Node->sibling_prev=NULL;

dir1Node->sibling_next=dir2Node;

dir2Node->parent=NULL;

dir2Node->child=libNode;

dir2Node->sibling_prev=dir1Node;

dir2Node->sibling_next=file1Node;

file1Node->parent=NULL;

file1Node->child=NULL;

file1Node->sibling_prev=dir2Node;

file1Node->sibling_next=etcNode;

etcNode->parent=NULL;

etcNode->child=NULL;

etcNode->sibling_prev=file1Node;

etcNode->sibling_next=NULL;

libNode->parent=dir2Node;

libNode->child=liuNode;

libNode->sibling_prev=NULL;

libNode->sibling_next=userNode;

userNode->parent=NULL;

userNode->child=NULL;

userNode->sibling_prev=libNode;

userNode->sibling_next=binNode2;

binNode2->parent=NULL;

binNode2->child=NULL;

binNode2->sibling_prev=userNode;

binNode2->sibling_next=NULL;

liuNode->parent=libNode;

liuNode->child=NULL;

liuNode->sibling_prev=NULL;

liuNode->sibling_next=sunNode;

sunNode->parent=NULL;

sunNode->child=NULL;

sunNode->sibling_prev=liuNode;

sunNode->sibling_next=ftiNode;

ftiNode->parent=NULL;

ftiNode->child=NULL;

ftiNode->sibling_prev=sunNode;

ftiNode->sibling_next=NULL;

}

//获取文件或目录名，并把指针指向其父亲结点

intFindFilename（charPara2[]）

{

i=strlen（Para2）-1;

j=0;

while（Para2[i]!

='/'&&i>=0）

{

filename[j]=Para2[i];

i--;j++;

}

filename[j]='\0';//获得逆序的文件或目录名，存入filename中

if（i<0）Para2[i+1]='\0';

elsePara2[i]='\0';

j--;

//filename逆转，获得正确的文件或目录名

for（i=0;i

{

tmp=filename[i];

filename[i]=filename[j];

filename[j]=tmp;

}

//returnfilename[i];

//查找路径

if（strlen（Para2）>0）

{

intsign=FindPath（Para2）;

if（sign==0）

return0;

}

return1;

}

//缓冲区安全输入子函数

//如果输入超过buffer_len，则截取前buffer_len-1长度的输入，

//buffer_len处字符用'/0'代替

intGetInput（char*buffer,unsignedintbuffer_len）

{

unsignedintcount=0;//intcount=0;

while（count

{

if（（buffer[count]=getchar（））==10）

{

buffer[count]='\0';

returncount;

}

count++;

}

while（getchar（）!

=10）;

buffer[buffer_len-1]='\0';

return-1;

}

//分解命令子函数

intParseCommand（）

{

charInputs[INPUT_LEN];

inti=0,j=0,ch;

unsignedintk=0;//intk=0;

printf（"%s>",path）;

printf（"#"）;

//获取输入

if（GetInput（Inputs,INPUT_LEN）==-1）

{

printf（"输入行太长。

\n"）;

return0;

}

Para1[0]=Para2[0]='\0';

//获取参数Para1，即操作名

while（Inputs[i]!

=''&&Inputs[i]!

='\0'&&i

{

Para1[i]=Inputs[i];

i++;

}//while

Para1[i]='\0';

//输入命令太长

if（i==（COMMAND_LEN-1））return1;

//获取参数2，即路径文件名

if（Inputs[i]!

='\0'）

{

while（Inputs[i]==''&&i

j=0;

while（Inputs[i]!

='\0'&&i

{

Para2[j]=Inputs[i];

i++;j++;

}

Para2[j]='\0';

}

Trim（Para1）;

Trim（Para2）;

//将操作名全部转换成小写字母

for（k=0;k

{

ch=tolower（（int）Para1[k]）;

Para1[k]=ch;

}

return1;

}

//cd功能处理子函数

intcdComd（）

{

if（!

CheckCommand（））//命令检查

return0;

if（strcmp（Para2,".."）==0）

{//对cd..命令的处理

inti;

while（cp->sibling_prev）

cp=cp->sibling_prev;

if（cp->parent）

{cp=cp->parent;}//找到父亲结点

else

{return0;}

//对当前路径进行相应处理

i=strlen（path）;

while（path[i]!

='/'&&i>0）i--;

if（i!

=0）

path[i]='\0';

else

path[i+1]='\0';

}

else{

FindPath（Para2）;//查找路径

}

printf（"进入工作目录\n"）;

printf（"\n\n模拟文件管理系统\n"）;

printf（"\ncd改变目录;creat创建文件;del删除文件;\n"）;

printf（"dir显示目录;md创建目录;rd删除目录;exit退出.\n"）;

printf（"\n--------------------------------------------------------------------------------\n"）;

return1;

}

//命令处理子函数

voidTrim（char*str）

{

intbegin,end;

char*tmp;

begin=0;

end=strlen（str）;

//找到字符串第一个非空格的位置

while（str[begin]==''&&str[begin]!

='\0'）

begin++;

//去除字符串尾部空格

while（str[--end]==''）;

str[end+1]='\0';

//除去空格

if（begin

{

tmp=（char*）malloc（（sizeof（char））*（end-begin+2））;

strcpy（tmp,&str[begin]）;

strcpy（str,tmp）;

free（tmp）;

}

}

//获取当前目录名子函数

intGetDir（intbegin,char*path,char*curDir）

{

inti=0;

intlen=strlen（path）;

while（!

（（path[begin]=='\\'）||（path[begin]=='/'））&&begin

{curDir[i++]=path[begin++];}

curDir[i]='\0';

Trim（curDir）;

returnbegin+1;

}

//查找路径函数

intFindPath（char*ph）

{

structFileNode*temp;//structFileNode*tp,*temp;

charoldpath[INPUT_LEN-COMMAND_LEN];

unsignedinti=0;//inti=0

intsign=1;

if（strcmp（ph,"/"）==0）

{//ph是根目录

cp=root;

strcpy（path,"/"）;

return1;

}

temp=cp;

strcpy（oldpath,path）;//保留原路径和指针

if（ph[0]=='/'）

{//指针指向根目录的左孩子

cp=root->child;

i++;//滤过'/'

strcpy（path,"/"）;

}

else{

if（cp!

=NULL&&cp!

=root）

strcat（path,"/"）;

if（cp&&cp->child）

{

if（cp->isdir）

cp=cp->child;//指针指向当前目录的左孩子

else{

printf（"路径错误!

\n"）;

return0;

}

}

}

while（i<=strlen（ph）&&cp）//继续查找指定路径，如遇到文件则报错

{

intj=0;

if（ph[i]=='/'&&cp->child）

{

i++;//略过'/'

if（cp->isdir）

cp=cp->child;//继续查找下级目录

else{

printf（"路径错误!

\n"）;

return0;

}

strcat（path,"/"）;

}

//curpath记录当前要找的路径名

while（ph[i]!

='/'&&i<=strlen（ph））

{

curpath[j]=ph[i];

i++;j++;

}

curpath[j]='\0';

while（（strcmp（cp->filename,curpath）!

=0||（cp->isdir!

=1））&&cp->sibling_next!

=NULL）

{cp=cp->sibling_next;}

if（strcmp（cp->filename,curpath）==0）

{

if（cp->isdir==0）

{

strcpy（path,oldpath）;

cp=temp;

printf（"是文件不是目录.\n"）;

return0;

}

strcat（path,cp->filename）;

}

if（strcmp（cp->filename,curpath）!

=0||cp==NULL）

{

strcpy（path,oldpath）;