文件系统实验

于 2023-05-22 10:52:39 发布
阅读量266 收藏 1
点赞数
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73476512/article/details/130801874
版权

1.实验目的

①阅读并调试一个简单的文件系统，模拟文件管理的工作过程。从而对各种文件操作进行命令的实质内容和执行过程有比较深入的了解。

②了解设计一个n个用户的文件系统，每个用户可以保存M个文件。用户在一次运行中只能打开一个文件，对文件必须设置保护措施，且至少有creat、delete、open、close、read、write等命令。

2.实验分析

该文件系统是一个多用户、多任务的文件系统。对用户和用户的文件数目并没有上限。也就是说，该系统允许任何用户申请空间，而且在目录下的文件数目并不做任何限制。

3.源程序

/********************************************************
*    文件名:Simple_file_system.cpp
*    功能:简单文件管理系统模拟程序
*********************************************************/
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include "conio.h"
#include<dos.h>

#define NULL 0
#define keynum 10
#define getspace(type) (type *)malloc(sizeof(type))

char cmd[64];
char buffer[36];
char user[32];

typedef char ALFA[12];
ALFA KWORD[keynum];
//-------------------------------------------------------
struct UFD{
	char filename[32];
	int safecode;
	long length;
} * curfile = NULL;
//-------------------------------------------------------
struct MFD{
	char username[32];
	bool filepoint;
} * curuser = NULL,*elseuser=NULL;
typedef UFD UFD;
typedef MFD MFD;
int main();
//---------------------------------------------------------
void KeyWord()
{
	strcpy(KWORD[1],"bye");
	strcpy(KWORD[3],"close");
	strcpy(KWORD[5],"delete");
	strcpy(KWORD[7],"open");
	strcpy(KWORD[9],"write");

}
//----------------------------------------------------------
int LoginDisplay()
{
	int SELETE_1 = 0;
	do
	{
		std::cout<<"    *****请选择操作*****\n1.用户登录  2.用户注册  0.退出"<<std::endl;
		std::cin>>SELETE_1;
	}while(SELETE_1<0 || SELETE_1>2);
	system("cls");
	return SELETE_1;
}
//---------------------------------------------------------
bool Login(int SELETE)
{
	FILE *fp, *fp1, *fp2;
	char name[12];
	switch(SELETE)
    {
        case 1:
            if ((fp = fopen("LOGIN.exe", "rb")) == NULL)
		{
			std:: cout<<"\n 错误:不能打开登录文件。"<<std::endl;
			getch();system("cls");
			return false;
		}
		curuser = getspace(MFD);
		std:: cout<<"\n *****登录***** \n用户名:";
		std::cin>>name;

		while(!feof(fp))
		{
			fread(curuser,sizeof(MFD),1,fp);
			if(strcmp(curuser->username,name)==0)
				break;
		}
		if(feof(fp))

		{
			std:: cout<<"\n 错误:该用户不存在。"<<std::endl;
			fclose(fp);
			return false;
		}
		else
		{
			fclose(fp);
			return true;
		}
		break;
	case 2:
		if((fp=fopen("LOGIN.exe","ab"))==NULL)
			fp=fopen("LOGIN.exe","wb+");
		char name[12];
		curuser = getspace(MFD);
		while(1)
		{
			std::cout<<"\n     *****新用户注册*****"<<std::endl;
			std::cout<<"用户名:";
			std::cin>>name;
			fp1=fopen("LOGIN.exe","rb");
			while(!feof(fp1))
			{
				fread(curuser,sizeof(MFD),1,fp1);
				if(strcmp(curuser->username,name) ==0)
				{
					std::cout<<"\n该用户已经存在，请重新输入!"<<std::endl;
					getch();
					break;
				}
			}
			if(feof(fp1))
			{
				strcpy(curuser->username,name);
				curuser->filepoint=NULL;
				fwrite(curuser,sizeof(MFD),1,fp);
				strcpy(user,curuser->username);
				strcat(user,".exe");
				fp2=fopen(user,"wb+");
				fclose(fp2);
				std::cout<<"\n注册成功!"<<std::endl;
				fclose(fp1);
				fclose(fp);
				break;
			}
		}
		fp=fopen("LOGIN.exe","rb");
		while(1)
		{
			fread(curuser,sizeof(MFD),1,fp);
			if(feof(fp))
				break;
			std::cout<<curuser->username<<std::endl;
			getch();
		}
		fclose(fp);
		return true;
		break;
	default:
		return false;
		break;
	}
}
//------------------------------------------------------------
void DisplayUFD()

{
	if(curuser->filepoint == false)
		std::cout<<"\n用户"<<curuser->username<<" 文件夹是空的"<<std::endl;
	else
	{
		FILE * fp;
		char filename[12];
		strcpy(filename,curuser->username);
		strcat(filename,".exe");
		if((fp=fopen(filename,"rb"))==NULL)
		{
			std::cout<<"\n无法打开用户:"<<curuser->username<<" 的文件!"<<std::endl;
			getch();
			return;
		}
		else
		{
			std::cout<<"用户:"<<curuser->username<<"目录下的文件:"<<std::endl;
			UFD * ufd;
			int i=0;
			ufd=getspace(UFD);
			while(1)
			{
				fread(ufd,sizeof(UFD),1,fp);
				if(feof(fp))
					break;
				else
					std::cout<<ufd->filename<<"\t"<<ufd->length<<"\t"<<ufd->safecode<<std::endl;
			}
		}
		fclose(fp);
	}
}
//--------------------------------------------------------------
void ByeFile(bool BOOL)
{
	FILE * infile, * outfile;
	char out[50];
	strcpy(out,"outfilelocate.exe");
	if((infile=fopen("LOGIN.exe","rb"))==NULL)
	{
		std::cout<<"\n保存错误。";
		return;
	}
	else
	{
		if((outfile=fopen(out,"wb+"))==NULL)
			//存放用户更新后的全部信息
		{
			std::cout<<"\n保存错误。";
			fclose(infile);return;
		}
		else
		{
			MFD * mfd=getspace(MFD);
			while(1)
			{
				fread(mfd,sizeof(MFD),1,infile);
				if(feof(infile))
					break;
				if((strcmp(mfd->username,curuser->username))==0)
				{
					if(BOOL)
						fwrite(curuser,sizeof(MFD),1,outfile);
					else continue;

				}
				else
					fwrite(mfd,sizeof(MFD),1,outfile);
			}
			fclose(infile);fclose(outfile);
			remove("LOGIN.exe");
			rename(out,"LOGIN.exe");
		}
	}

}
//--------------------------------------------------------------
bool ClearUserFile()
{
	FILE * fp;
	char file[50];
	strcpy(file,curuser->username);
	strcat(file,".exe");
	if((fp=fopen(file,"rb"))==NULL)
	{
		//fclose(fp);
		std::cout<<"\n该用户不存在!";return true;
	}
	else
	{
		UFD * ufd=getspace(UFD);
		while(1)
		{
			fread(ufd,sizeof(UFD),1,fp);
			if(feof(fp))
				break;
			else
				remove(ufd->filename);
		}
		fclose(fp);
		return true;
	}
}
//------------------------------------------------------------
void ClearUserMes()
{
	char name[50];
	strcpy(name,curuser->username);
	strcat(name,".exe");
	remove(name);
	ByeFile(false);
}
//------------------------------------------------------------
void DeleteUser()
{
	char ch;
	std::cout<<"\n该操作将会是你在系统所有信息删除，下次登录时你必须重新申请用户名!"<<std::endl;
	std::cout<<"\n你确定要删除你在系统中的注册信息吗？ Y/N"<<std::endl;
	std::cin>>ch;
	switch(ch)
	{
	case'Y':
	case 'y':
		if(ClearUserFile())



			ClearUserMes();
		break;
	default:
		std::cout<<"\n你取消了此操作!";
		break;
	}
}
//-------------------------------------------------------------
void CreatFile()
{
	FILE * fp;
	curuser->filepoint=true;

	if((fp=fopen(buffer,"r"))==NULL)
	{
		if((fp=fopen(buffer,"w"))==NULL)
		{
			std::cout<<"\n创建文件失败!";
			//fclose(fp);
			return;
		}
		fclose(fp);
	}
	else
	{
		std::cout<<"\n该文件已经存在，创建另一个文件？ Y/N";
		char ch;
		std::cin>>ch;
		switch(ch)
		{
		case'Y':
		case'y':
			std::cout<<"\n输入新文件名:";
			std::cin>>buffer;
			strcat(buffer,".txt");
			fclose(fp);
			if((fp=fopen(buffer,"w"))==NULL)
			{
				std::cout<<"\n创建文件失败!";
				//fclose(fp);
				return;
			}
			fclose(fp);
			break;
		default:
			fclose(fp);
			return;
		}
	}
	strcpy(user,curuser->username);
	strcat(user,".exe");
	curfile = getspace(UFD);
	strcpy(curfile->filename,buffer);
	curfile->length=0;
	curfile->safecode=30;

	if((fp=fopen(user,"ab"))==NULL)
	{
		std::cout<<"\n错误:你可能不是合法用户。"<<std::endl;
		getch();
	}
	else
	{
		fwrite(curfile,sizeof(UFD),1,fp);
		std::cout<<"\n文件"<<curfile->filename<<" 创建成功!";
	}
	fclose(fp);
}
//---------------------------------------------------------------
void DeleteFile()
{
	char ch;
	FILE * infile, * outfile;
	std::cout<<"\n确定要删除文件:"<<buffer<<" Y/N"<<std::endl;
	std::cin>>ch;
	switch(ch)
	{
	case'Y':
	case'y':

		char out[50],in[50];
		strcpy(out,"outfilelocate.exe");
		strcpy(in,curuser->username);
		strcat(in,".exe");
		if((infile=fopen(in,"rb"))==NULL)
		{
			std::cout<<"\n保存错误。";
			//fclose(infile);
			return;
		}
		else
		{
			if((outfile=fopen(out,"wb+"))==NULL)
			{
				std::cout<<"\n保存错误。";
				fclose(infile);return;
			}
			else
			{
				UFD * ufd = getspace(UFD);
				while(1)
				{
					fread(ufd,sizeof(UFD),1,infile);
					if(feof(infile))
						break;
					if((strcmp(ufd->filename,buffer))==0)
						continue;
					else
						fwrite(ufd,sizeof(UFD),1,outfile);
				}
				fclose(infile);fclose(outfile);
				remove(in);
				rename(out,in);
			}
		}
		remove(buffer);
		break;
	default:
		break;
	}
}
//---------------------------------------------------------------
void ListAllFile()
{
	DisplayUFD();
}
void WriteLengthToFile(int Len,bool BOOL);
//---------------------------------------------------------------
void OpenFile()
{
	FILE * fp;
	char ch;
	int i=0;
	system(buffer);
	fp=fopen(buffer,"r");
	while(1){
		if(feof(fp))
			break;
		ch=fgetc(fp);
		i++;
	}
	WriteLengthToFile(i,false);
}
//----------------------------------------------------------------
bool QueryModElse(bool BOOL,bool &flag)

{
	FILE * fp;
	char user[50];
	UFD * ufd=getspace(UFD);
	strcpy(user,elseuser->username);
	strcat(user,".exe");

	if((fp=fopen(user,"rb"))==NULL){
		//fclose(fp);
		std::cout<<"\n操作出现错误，对此我们表示歉意!";return false;
	}
	else{
		while(1){
			fread(ufd,sizeof(UFD),1,fp);
			if(feof(fp)){
				fclose(fp);return false;
			}
			if(strcmp(ufd->filename,buffer)==0){
				if(BOOL)
				{
					if(ufd->safecode==31 || ufd->safecode==33)
						return true;
					else{
						std::cout<<"\n你无权对文件"<<buffer<<"执行此操作!";
						flag=true;return false;}


				}
				else
				{
					if(ufd->safecode ==32 || ufd->safecode ==33)
						return true;
					else{
						std::cout<<"\n你无权对文件"<<buffer<<"执行此操作!";
						flag=true;return false;}
				}
			}
		}
	}
}
//-----------------------------------------------------------------------
bool QueryMod(bool BOOL)
{
	FILE *fp,*fp1;
	bool flag=false;
	char user[50];
	UFD * ufd= getspace(UFD);
	strcpy(user,curuser->username);
	strcat(user,".exe");

	if((fp=fopen(user,"rb"))==NULL){
		//fclose(fp);
		std::cout<<"\n操作出现错误，对此我们表示歉意!";return false;
	}
	else{
		while(1){
			fread(ufd,sizeof(UFD),1,fp);
			if(feof(fp)){
				fclose(fp);
				fp1=fopen("LOGIN.exe","rb");
				elseuser = getspace(MFD);
				bool BOOL_1=false;
				while(1){
					fread(elseuser,sizeof(MFD),1,fp1);
					if(feof(fp1) && ! BOOL_1)

						return false;
					if(elseuser != curuser){
						if((BOOL_1==QueryModElse(BOOL,flag)))
							return true;
						if(flag)
							return false;
					}
				}
			}
			if(strcmp(ufd->filename,buffer)==0){

				fclose(fp);return true;
			}
		}
	}
}
//---------------------------------------------------------------
bool WriteRight(int len,bool BOOL)
{
	char user[50],outfile[50];
	FILE * fp,*fp1;
	strcpy(user,elseuser->username);
	strcat(user,".exe");
	if((fp=fopen(user,"rb"))==NULL){
		//fclose(fp);
		return false;
	}
	else{
		UFD * ufd = getspace(UFD);
		while(1){
			fread(ufd,sizeof(UFD),1,fp);
			if(feof(fp)){
				fclose(fp);return false;
			}
			if((strcmp(ufd->filename,buffer))==0){

				strcpy(outfile,"outfilelocate.exe");
				if((fp1=fopen(outfile,"wb+"))==NULL){
					std::cout<<"\n错误:写入文件长度出错_3。";
					//fclose(fp1);
					fclose(fp);return false;
				}
				else{
					fclose(fp);
					fp=fopen(user,"rb");

					while(1){
						fread(ufd,sizeof(UFD),1,fp);
						if(feof(fp))
							break;
						if(strcmp(ufd->filename,buffer)==0){
							if(BOOL) ufd->length+=len;
							else ufd->length =len;
						}
						fwrite(ufd,sizeof(UFD),1,fp1);
					}
					fclose(fp);fclose(fp1);
					remove(user);
					rename(outfile,user);
					return true;
				}
			}
		}
	}
}
//----------------------------------------------------------------------
void WriteLengthToFile(int Len,bool BOOL)
{
	FILE * fp;
	if((fp=fopen("LOGIN.exe","rb"))==NULL){
		std::cout<<"\n写入文件长度错误_1!";
		//fclose(fp);
		return;
	}
	else{
		elseuser=getspace(MFD);
		while(1){
			fread(elseuser,sizeof(MFD),1,fp);
			if(feof(fp))
				break;
			else{
				if(WriteRight(Len,BOOL)){
					fclose(fp);return;
				}
			}
		}
		std::cout<<"\n写入文件长度错误_2!";
		fclose(fp);return;
	}
}
//------------------------------------------------------------------
void WriteFile()
{
	if(!QueryMod(true))
		return;
	char ch;
	int i=0;
	FILE * fp;
	if((fp=fopen(buffer,"r"))==NULL)
	{
		std::cout<<"\n该文件不存在,请创建该文件后再写入。";
		//fclose(fp);
		return;
	}
	fclose(fp);
	std::cout<<"\n请选择写入方式："<<std::endl;
	std::cout<<"  1.覆盖原文件    2.在原文件末尾写入    3.取消"<<std::endl;
    std::cin >> ch;
	std::cout<<"开始输入正文:"<<std::endl;
	switch(ch)
	{
	case '1':
		if((fp=fopen(buffer,"w"))==NULL)
			std::cout<<"\n文件打开失败。";
		else
		{
			ch=getchar();
			while(ch!='#')
			{
				i++;
				fputc(ch,fp);
				ch=getchar();
			}
		}
		fclose(fp);
		WriteLengthToFile(i,false);
		break;
	case '2':
		if((fp=fopen(buffer,"a"))==NULL)
			std::cout<<"\n文件打开失败。";
		else
		{
			ch=getchar();
			while(ch!='#')
			{
				i++;
				fputc(ch,fp);
				ch=getchar();
			}
		}
		fclose(fp);
		WriteLengthToFile(i,true);
		break;
	default:
		break;
	}
}
//------------------------------------------------------------------
void ReadFile()
{
	if(!QueryMod(false))
		return;
	FILE * fp;
	if((fp=fopen(buffer,"r"))==NULL)
	{
		std::cout<<buffer;
		std::cout<<"\n该文件不存在。";
		return;
	}
	else{
		char ch;
		ch=fgetc(fp);
		while(ch!=EOF)
		{
			putchar(ch);
			ch=fgetc(fp);
		}
		std::cout<<std::endl;
	}
	fclose(fp);
}
//-----------------------------------------------------------------
void ChangeMod()
{
	int mod=40;
	FILE * fp,* infile, * outfile;

	char in[50],out[50];
	UFD * ufd = getspace(UFD);
	strcpy(in,curuser->username);
	strcat(in,".exe");
	strcpy(out,"outfilelocate.exe");

	if((fp=fopen(in,"rb"))==NULL){
		//fclose(fp);
		std::cout<<"\n操作出现错误，对此我们表示歉意!";
		return;
	}
	else{
		while(1){


			fread(ufd,sizeof(UFD),1,fp);
			if(feof(fp)){

				std::cout<<"\n你没有权限对文件"<<buffer<<"执行该操作!";
				fclose(fp);return;
			}
			if(strcmp(ufd->filename,buffer)==0){
				fclose(fp);break;
			}
		}
	}
	bool flag1=true;
	while(flag1)
	{
		std::cout<<"\n输入文件  "<<buffer<<"的新的权限值:";
		std::cin>>mod;
		if(mod<30 || mod>33)
		{
			std::cout<<"\n错误:权限值必须在30~33之间";
			continue;
		}
		else{
			char ch;
			switch(mod){
			case 30:
				std::cout<<"\n当前权限设置:其他用户对"<<buffer<<"既没读权也没写权!";
				break;
			case 31:
				std::cout<<"\n当前权限设置:其他用户对"<<buffer<<"没读权但有写权!";
				break;
			case 32:
				std::cout<<"\n当前权限设置:其他用户对"<<buffer<<"有读权但没写权!";
				break;
			case 33:
				std::cout<<"\n当前权限设置:其他用户对"<<buffer<<"既有读权也有写权!";
				break;
			default: break;
			}
			std::cout<<"\n确认按Y键，取消按N键";
			std::cin>>ch;
			switch(ch){
			case 'Y':
			case 'y':flag1=false;break;
			default:flag1=true;
			}
		}
	}
	if((infile=fopen(in,"rb"))==NULL){
		std::cout<<"\n操作出现错误，对此我们表示歉意!";fclose(infile);
		return;
	}
	else{
		if((outfile=fopen(out,"wb+"))==NULL){
			std::cout<<"\n操作出现错误，对此我们表示歉意!";
			fclose(infile);//fclose(outfile);
			return;
		}
		else{
			while(1)
			{
				fread(ufd,sizeof(UFD),1,infile);
				if(feof(infile))
					break;
				if((strcmp(ufd->filename,buffer))==0)
					ufd->safecode=mod;
				fwrite(ufd,sizeof(UFD),1,outfile);
			}
			fclose(infile);fclose(outfile);
			remove(in);
			rename(out,in);
		}
	}
}
//------------------------------------------------------------------------
void Execute(int i,int len,int cmdset)
{
	int j=0;
	for(;i<len;i++)
	{
		if(cmd[i]=='>' || cmd[i]==' '){
			//buffer[i] ='\0';
			break;
		}
		/* if(i==len-1)
		 *
		{
			buffer[j]=cmd[i];
			buffer[j+1]='\0';
			break;
		} */
			buffer[j]=cmd[i];j++;
	}
	buffer[j]='\0';
	strcat(buffer,".txt");
	switch(cmdset)
	{
	case 1:
		ByeFile(true);
		system("cls");
		break;
	case 2:
		if((strcmp(buffer,".txt"))==0){
			std::cout<<"\n输入命令出错!";
			return;
		}
		ChangeMod();
		break;
	case 3:
		DeleteUser();
		break;
	case 4:
		if((strcmp(buffer,".txt"))==0){
			std::cout<<"\n输入命令出错!";
			return;
		}
		CreatFile();
		break;
	case 5:
		if((strcmp(buffer,".txt"))==0){
			std::cout<<"\n输入命令出错!";
			return;
		}
		DeleteFile();
		break;
	case 6:
		ListAllFile();
		break;
	case 7:
		if((strcmp(buffer,".txt"))==0){
			std::cout<<"\n输入命令出错!";
			return;
		}
		OpenFile();
		break;
	case 8:
		if((strcmp(buffer,".txt"))==0){
			std::cout<<"\n输入命令出错!";
			return;
		}
		ReadFile();
		break;
	case 9:
		if((strcmp(buffer,".txt"))==0){
			std::cout<<"\n输入命令出错!";
		return;
	}
	WriteFile();
	break;
	default:
		break;
}
}
//----------------------------------------------------------------------
void Command()
{
	int len=0,i,j;
	int cmdset;
	while(1)
	{
		cmdset = 0;
		std::cout<<"\nrun\\";
		std::cin>>cmd;
		len = strlen(cmd);
		i=0;j=0;
		while(cmd[i]=='>' || cmd[i]==' '){i++;}
		for(;i<len;i++)
		{
		   if(cmd[i]=='>'|| cmd[i]==' ' || i==len-1)
		   {
		      if(cmd[i]=='>' || cmd[i]==' ')
		          buffer[j]='\0';
		      else
		           if(i==len-1)
		           {
		            buffer[j]=cmd[i];
		            buffer[j+1]='\0';
		            }
		        i++;
		        j=0;
		        int low=1,mid,high=keynum-1;
		        bool BOOL=false;
		        while(low<=high){
		              mid=(low+high)/2;
		              if(strcmp(buffer,KWORD[mid])<=0)high=mid-1;
		              if(strcmp(buffer,KWORD[mid])>=0)low=mid+1;
		              if(strcmp(buffer,KWORD[mid])==0){
		                        BOOL=true;
		                        break;
		               }
		        }
		        if(!BOOL)
		        {
		             std::cout<<"\n"<<buffer<<"不是系统定义的命令";
					 cmdset=0;break;
		         }
		         else{cmdset=mid;break;}
		    }
		    else{
		        buffer[j]=cmd[i];
		    j++;
		    }
		}
		if(cmdset==0)continue;
		while(cmd[i]=='>'||cmd[i]==' '){i++;}
		buffer[0]='\0';
		Execute(i,len,cmdset);
	}
}
//----------------------------------------------------------------------
int main()
{
 while(1){
      int SELETE=LoginDisplay();
      if(SELETE==0)
           exit(0);
      bool BOOL=Login(SELETE);
      if(BOOL)
      {
       KeyWord();
       DisplayUFD();
           Command();
       }
   }
}

薛定谔的猫01
关注
实现简单的文件系统
01-26
实验内容： 通过对具体的文件存储空间的管理、文件的物理结构、目录结构和文件操作的实现，加深对文件系统内部功能和实现过程的理解。 要求： 1.在内存中开辟一个虚拟磁盘空间作为文件存储器，在其上实现一个简单的单用户文件系统。在退出这个简单的文件系统时，将该虚拟文件系统保存到磁盘上，以便下次再将它恢复到内存的虚拟磁盘空间中。 2.提供以下操作： •new：建立一个新的简单文件系统； •sfs：打开一个简单文件系统； •exit：退出打开的简单文件系统； •mkdir：创建子目录； •rmdir：删除子目录； •ls：显示目录； •cd：更改当前目录； •create：创建文件； •open：打开文件； •close：关闭文件； •read：读文件； •write：写文件； •delete：删除文件。
操作系统之文件系统设计一个n 个用户的文件系统，每次用户可保存m 个文件，用户在一次运行中只能打开一个文件，对文件必须设置保护措施。至少要有create,delete,open,close,read,write等命令
06-23
实验要求：设计一个n 个用户的文件系统，每次用户可保存m 个文件，用户在一次运行中只能打开一个文件，对文件必须设置保护措施。至少要有create,delete,open,close,read,write等命令。 概要设计： TForm1 *Form1; MFD Mfd; //用户内存块 UFD Ufd; //用户文件内存块 AFD Afd; //打开文件内存块 FILE *Mfp; //用户列表文件 FILE *Ufp; //当前用户文件指针 String CurrUser;//当前用户 添加用户模块： void TForm1::InserMFD(String User, String FilePointer,MFD &Mfd)
操作系统文件管理
hlp_whale的博客
06-06 1926
1.用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程，从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。 2.要求设计一个 n个用户的文件系统，每次用户可保存m个文件，用户在一次运行中只能打开一个文件，对文件必须设置保护措施，且至少有Create、delete、open、close、read、write等命令。设计一个10个用户的文件系统，每次用户可保存10个文件，一次运行用户可以打开5个文件。 1.程序采用二级文件目录（即设置主目录[MFD]）和用户文件目录（UED）；另外，为打开
简单的文件系统模拟C/C++（操作系统）
热门推荐
g15827636417的博客
12-30 3万+
一、目的与要求 目的 文件系统是操作系统的一个重要组成部分，也是与用户关系极为密切的部分。学生应独立的用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程，从而对各种文件操作命令的实质内容和执行过程有比较深入的了解，掌握它们的实施方法，加深对教材中有关内容的理解。‘ 要求 (1) 设计一个n个用户的文件系统，每个用户最多可保存m个文件。 (2) 限制用户在一次运行中只能打开一个文件。(3
文件操作练习
最新发布
qq_53190275的博客
03-25 371
文件操作练习
操作系统实验报告（文件管理）
12-15
在操作系统实验报告“文件管理”部分，我们关注的是如何为Unix/Linux系统设计一个简单的二级文件系统。这个实验旨在让学生深入理解文件系统的内部运作机制及其功能实现。以下是该实验涉及的关键知识点： 1. 文件...
操作系统——简单文件系统模拟实验
12-21
在内存中模拟一个FAT格式的文件系统，完成文件的创建和索引功能，实现以下命令接口： （1）新建文件，格式：mkfile filename filecontent filename：文件名 filecontent：文件内容(字符) 实现按FAT格式写FAT表...
操作系统文件管理实验报告(1).doc
12-22
1. 熟悉 WindowsXP 的文件系统。 2. 掌握资源管理器的使用方法。 3. 熟练掌握在 WindowsXP 资源管理器下，对文件（夹）的选择、新建、移动、复制、删除、重命名的操作方法。 实验内容： 1. 启动资源管理器并利用...
Linux文件系统实验
01-10
在Linux怎样制作RAMDISK、JFFS2文件系统映像文件； 在Linux中将zImage加入到JFFS2文件系统中，然后在u-boot中加载并运行该Linux内核文件
操作系统实验4_文件系统
07-22
本实验要求在假设的I/O 系统之上开发一个简单的文件系统，这样做 既能让实验者对文件系统有整体了解，又避免了涉及过多细节。用户通过 create, open, read 等命令与文件系统交互。文件系统把磁盘视为顺序编号 的逻辑块序列，逻辑块的编号为0 至L
一个简单的文件系统（操作系统课程设计）
01-06
一个简单的文件系统（操作系统课程设计）主要任务是对用户文件和系统文件进行管理，以方便用户使用，并保证文件的安全性。文件管理具有对文件存储空间的管理、目录管理、文件的读/写管理以及文件的共享与保护功能。从用户的角度看，目录在用户（应用程序）所需要的文件名和文件之间提供一种映射，所以目录应实现“按名存取”，“按名存取”是目录管理中最基本的功能，也是文件系统向用户提供的最基本的服务。目录管理中有多种实现机制，其中二级目录机制可以解决多用户之间的文件重名问题，文件系统可以在目录上实现访问限制。
熟悉ct2的文件系统
04-13
熟悉ct2的文件系统 熟悉ct2的文件系统 熟悉ct2的文件系统 熟悉ct2的文件系统
简单文件系统
12-02
　　编译执行模拟文件系统的实现程序，根据系统实现的功能反复操作，直至熟悉所有功能。在磁盘上建立一个文件作为文件存储器，此文件相当于一个磁盘分区，并在其上实现一个简单的单用户文件系统。
文件管理
yuan08shandong的博客
12-22 384
文件操作三步：打开、读写、关闭。 一、文件的打开与关闭 FILE *fp; fp = fopen("test.txt", "r"); ...... fclose(fp); 二、文件操作函数 1、单字符的读写函数 int fputc(int ch, FILE *fp); int fgetc(FILE *fp); 每次写入和读入一个字符，文件位置指针会自动指向下一个字符
广工操作系统课设--多用户多级目录的文件系统
weixin_51712663的博客
07-04 3548
广工操作系统课设--多用户多级目录的文件系统
操作系统期末实验：多用户二级文件系统
定期分享我的发现和想法，感谢你的陪伴和支持
10-21 1万+
设计一个多用户的二级文件系统，能够实现简单的文件操作。具体包括如下几条命令： （1）Dir 列文件目录； （2）Create 创建文件 （3）Delete 删除文件 （4）Deldir 删除目录 （5）Open 打开文件 （6）Close 关闭文件 （7）Read、Write读写文件 （8）Search 查询文件 （9）Copy 拷贝文件 （10）Cut 剪切文件。本课程设计要求按照学校有关
操作系统课程设计----模拟文件管理系统（c语言）
waibibabO_的博客
04-18 2万+
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 一、要求 1．采用高级语言编写程序模拟文件系统，文件系统采用多级目录结构，实现对文件和目录的创建、删除、重命名、变更权限、显示文件内容、修改文件内容等操作。 2．撰写课程设计报告。 二、课程设计内容 编写程序模拟一个简单的文件系统，具体实验内容如下： （1）实现多级目录结构，而非二级目录结构。 （2）实现文件和目录的创建、删除、重命名和读写权限控制功能。 （3）实现显示文件内容和更改文件内容的功能。 （4）创建文件或目录时，采用动态申请的.
模拟文件系统的设计与实现
刘映辰的博客
06-10 6884
模拟文件系统的实现的基本功能，了解文件系统的基本结构和文件系统的管理方法,加深了解文件系统的内部功能的实现。通过高级语言编写和实现一个简单的文件系统，模拟文件管理的工作过程，从而对各种文件操作系统命令的实质内容和执行过程有比较深入的了解。通过编程实现这些算法,更好地掌握操作系统的原理及实现方法,提高综合运用各专业课知识的能力。 本文是在学习完操作系统课程后所完成的课程设计，文中就模拟文件管理系统进行了简单的研究。文件系统的目录结构采用类似 Linux 的树状结构。 在此文件管理系统中,可实现的操作有: 改变
嵌入式Linux RAMFS文件系统实验
实验二和实验三则分别涉及NFS文件系统实验和Samba的介绍与应用，进一步拓宽了对网络文件共享和跨平台文件访问的理解。 嵌入式文件系统的选用和配置对于嵌入式系统的性能和稳定性起着关键作用。通过建立和使用RAMFS...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值