简单的文件系统模拟C/C++（操作系统）

最新推荐文章于 2024-05-05 14:53:52 发布
最新推荐文章于 2024-05-05 14:53:52 发布
阅读量3.7w 收藏 378
点赞数 64
分类专栏： 计算机操作系统 文章标签： 操作系统 文件系统 语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/g15827636417/article/details/53947230
版权

一、目的与要求

  1. 目的

文件系统是操作系统的一个重要组成部分，也是与用户关系极为密切的部分。学生应独立的用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程，从而对各种文件操作命令的实质内容和执行过程有比较深入的了解，掌握它们的实施方法，加深对教材中有关内容的理解。‘

  1. 要求
    (1) 设计一个n个用户的文件系统，每个用户最多可保存m个文件。

(2) 限制用户在一次运行中只能打开一个文件。

(3) 系统应能检查输入命令的正确性，出错时要能显示出错原因。

(4) 对文件必须设置保护措施，如只能执行，允许读，允许写等。在每
次打开文件时，根据本次打开的要求，再次设置保护级别，即可有二级保护。

(5) 对文件的操作至少应有下面几条命令：
create 建立文件
delete 删除文件
open 打开文件
close 关闭文件
read 读文件
write 写文件

二、内容

(1) 设计一个共有10个用户的文件系统，每个用户最多可保存10个文件，一次运行过程中用户可同时打开5个文件。

(2) 程序采用二级文件目录，即设置了主文件目录（MFD）和用户文件目录（UFD）。前者应包含文件主（即用户）及他们的目录区指针；后者应给出每个文件主占有的文件目录，即文件名、保护码、文件长度以及它们存放的位置等。另外为打开文件设置了运行文件目录（AFD），在文件打开时应填入打开文件号，本次打开保护码和读写指针等。

(3) 为了便于实现，对文件的读写作了简化，在执行读写命令时，只修改读写指针，并不进行实际文件的读写操作。

主要数据结构：

① 主文件目录（MFD）和用户文件目录（UFD）

这里写图片描述

② 打开文件目录（AFD）

这里写图片描述

三、实现代码

/*
 *模拟文件管理
 */
#include<iostream>
#include<malloc.h>
#include<string.h>
using namespace std ;

/*
 *定义文件数据结构
 */
typedef struct file
{
    char file_name[20] ;
    bool file_protect[3] ;
    bool open_file_protect[3] ; //仅在文件打开时有效
    int  read , write ; //定义为读写指针
    int  file_length ;
    struct file *next ;
} File ;

/*
 *用户与文件的映射
 */
typedef struct x_map
{
    char userName[20] ;
    File *file ;
    struct x_map *next ;
} Map ;

/*
 *定义主文件目录
 */
typedef struct mfd
{
    Map *head , *tail ;
} MFD ;

/*
 *打开文件目录
 */
typedef struct afd
{
  File *head , *tail ;
  int max_open ;
  int current_open ;
} AFD ;

/*
 *进行用户的初始化
 */
void initUser(MFD *mfd) ;

/*
 *进行系统用户的输出
 */
void displayUser(MFD *mfd) ;

/*
 *进行用户的查找，找到则返回用户映射指针
 */
Map * queryUser(char userName[] , MFD *mfd) ;

/*
 *进行文件的创建操作
 *成功则返回true ， 否则返回false
 */
bool createFile(Map *user , char file_name[] , bool file_protect[3] , int file_length) ;

/*
 *进行文件删除操作
 */
bool deleteFile(Map *user , char file_name[] , AFD *afd) ;

/*
 *进行文件打开操作
 */
bool openFile(Map *user , char file_name[] , AFD *afd , bool open_file_protect[]) ;

/*
 *进行读操作
 */
bool readFile(AFD *afd , char file_name[]) ;

/*
 *进行文件的写操作
 */
bool writeFile(AFD *afd , char file_name[]) ;

/*
 *关闭文件
 */
 bool closeFile(AFD *afd , char file_name[]) ;

/*
 *进行用户文件的显示
 */
void displayUserFile(Map *user) ;

/*
 *显示打开的文件
 */
void displayOpenFile(AFD *afd , Map *user) ;

/*
 *测试主函数
 */
int main()
{
    MFD *mfd ;
    mfd = (MFD*)malloc(sizeof(MFD)) ;
    if(mfd == NULL)
    {
        exit(0) ;
    }
    mfd->head = mfd->tail = NULL ;
    initUser(mfd) ;
    displayUser(mfd) ;

    char userName[20] ;
    while(true)
    {
        cout<<"Please choose user to login : " ;
        cin>>userName ;
        Map *user ;
        user = queryUser(userName , mfd) ;
        if(user == NULL)
        {
            cout<<"No such user ! "<<endl;
        }
        else
        {
          //为用户初始化打开文件目录
          AFD *afd ;
          afd = (AFD*)malloc(sizeof(AFD)) ;
          if(afd == NULL)
          {
              cout<<"The memory is not enough ! "<<endl ;
              exit(0) ;
          }
          afd->head = afd->tail = NULL ;
          afd->max_open = 5 ;
          afd->current_open = 0 ;

          char command[20] ;
          char file_name[20] ;
          bool file_protect[3] ;
          bool open_file_protect[3] ;
          int file_length ;
          while(true)
          {
              cout<<userName<<">>" ;
              cin>>command ;
              //输入命令进行操作
              if(strcmp(command , "create") == 0)
              {
                  cout<<"Please file (file_name file_protect file_length) : " ;
                  cin>>file_name>>file_protect[0]>>file_protect[1]>>file_protect[2]>>file_length ;
                  createFile(user , file_name , file_protect , file_length) ;
                  displayUserFile(user) ;
              }
              else if(strcmp(command , "delete") == 0)
              {
                  cout<<"Please input the file's name you want to delete : " ;
                  cin>>file_name ;
                  deleteFile(user , file_name , afd) ;
                  displayUserFile(user) ;
              }
              else if(strcmp(command , "open") == 0)
              {
                  cout<<"Please input the file name you want to open : " ;
                  cin>>file_name>>open_file_protect[0]>>open_file_protect[1]>>open_file_protect[2] ;
                  openFile(user , file_name , afd , open_file_protect) ;
                  displayOpenFile(afd , user) ;
              }
              else if(strcmp(command , "close") == 0)
              {
                  cout<<"Please input the file you want to close : " ;
                  cin>>file_name ;
                  closeFile(afd , file_name) ;
                  displayOpenFile(afd , user) ;
              }
              else if(strcmp(command , "read") == 0)
              {
                  cout<<"Please input the file you want to read : " ;
                  cin>>file_name ;
                  readFile(afd , file_name) ;
                  displayOpenFile(afd , user) ;
              }
              else if(strcmp(command , "write") == 0)
              {
                  cout<<"Please input the file you want to write : " ;
                  cin>>file_name ;
                  writeFile(afd , file_name) ;
                  displayOpenFile(afd , user) ;
              }
              else if(strcmp(command , "exit") == 0)
              {
                  break ;
              }
              else
              {
                  cout<<"No such command \""<< command <<"\""<<endl ;
              }
          }
        }
    }
    return 0 ;
}

void initUser(MFD *mfd)
{
    //初始化十个不同用户
    for(int i = 1 ; i <= 10 ; i++)
    {
        Map *m ;
        m = (Map*)malloc(sizeof(Map)) ;
        if(m == NULL)
        {
            exit(0) ;
        }
        cout<<"Please input init user name : " ;
        cin>>m->userName ;
        m->file = NULL ;
        m->next = NULL ;
        if(mfd->head == NULL)
        {
            mfd->head = mfd->tail = m ;
        }
        else
        {
            mfd->tail->next = m ;
            mfd->tail = m ;
        }
    }
}

void displayUser(MFD *mfd)
{
    Map *m = NULL ;
    m = mfd->head;
    cout<<"user : " ;
    while(m)
    {
        cout<<m->userName<<" " ;
        m = m->next ;
    }
    cout<<endl ;
}

Map * queryUser(char userName[] , MFD *mfd)
{
    Map *m = NULL ;
    m = mfd->head ;
    while(m)
    {
        if(strcmp(userName , m->userName) == 0)
        {
            return m ;
        }
        m = m->next ;
    }
    return NULL ;
}

bool createFile(Map *user , char file_name[] , bool file_protect[3] , int file_length)
{
    File *file ;
    file = (File*)malloc(sizeof(File)) ;
    if(file == NULL)
    {
        return false ;
    }

    //进行文件的初始化
    strcpy(file->file_name , file_name) ;
    file->file_protect[0] = file_protect[0] ;
    file->file_protect[1] = file_protect[1] ;
    file->file_protect[2] = file_protect[2] ;
    file->file_length = file_length ;
    file->read = file->write = 0 ;
    file->next = NULL ;

    if(user->file == NULL)
    {
        user->file = file ;
    }
    else
    {
       File *op  , *preOp = NULL ;
       op = user->file ;
       //查找是否存在同名文件
       while(op)
       {
           if(strcmp(op->file_name , file->file_name) == 0)
           {
               cout<<"The file name "<<file->file_name<<" is already exit ! "<<endl ;
               return false ;
           }
        preOp = op ;
        op = op->next ;
       }
       preOp->next = file ;
    }
}

void displayUserFile(Map *user)
{
    cout<<"The fileList of "<<user->userName<<endl ;
    File *file = NULL ;
    file = user->file ;
    while(file)
    {
        cout<<file->file_name<<" "<<file->file_protect[0]<<" "<<file->file_protect[1]<<" "<<file->file_protect[2]<<" "<<file->file_length<<endl ;
        file = file->next ;
    }
}

bool deleteFile(Map *user , char file_name[] , AFD *afd)
{
  File *file = NULL , *prefile = NULL , *temp ;
  file = afd->head ;
  //在打开文件中查找
  while(file)
  {
      if(strcmp(file_name , file->file_name) == 0)
      {
          cout<<"\""<<file_name<<"\" is open , please close it before ! \n" ;
          return false ;
      }
      file = file->next ;
  }
  file = user->file ;
  //在文件中进行查找
  while(file)
  {
    if(strcmp(file_name , file->file_name) == 0)
    {
       if(file == user->file)
       {
           temp = file ;
           user->file = file->next ;
       }
       else
       {
           temp = file ;
           prefile->next = file->next ;
       }
       delete temp ;
       return true ;
    }
    prefile = file ;
    file = file->next ;
  }
  if(prefile->next == NULL)
  {
      cout<<"user "<<user->userName<<" has not the file \""<<file_name<<"\""<<endl;
  }
  return false ;
}

bool openFile(Map *user , char file_name[] , AFD *afd , bool open_file_protect[])
{
   File *file = NULL ;
   file = user->file ;
   while(file)
   {
       if(strcmp(file->file_name , file_name) == 0)
       {
           break ;
       }
       file = file->next ;
   }
   if(file)
   {
       File *xfile ;
       xfile = (File*)malloc(sizeof(File)) ;
       if(xfile == NULL)
       {
           return false ;
       }
       *xfile = *file ;
       //根据文件的权限进行打开权限的赋值
       if(xfile->file_protect[0] >= open_file_protect[0])
       {
           xfile->open_file_protect[0] = open_file_protect[0] ;
       }
       else
       {
            cout<<"no read priority ! "<<endl;
            return false ;
       }
       if(xfile->file_protect[1] >= open_file_protect[1])
       {
           xfile->open_file_protect[1] = open_file_protect[1] ;
       }
       else
       {
            cout<<"no write priority ! "<<endl;
            return false ;
       }
        if(xfile->file_protect[2] >= open_file_protect[2])
       {
           xfile->open_file_protect[2] = open_file_protect[2] ;
       }
       else
       {
            cout<<"no excute priority ! "<<endl;
            return false ;
       }
       xfile->next = NULL ;
       if(afd->head == NULL)
       {
           afd->head = afd->tail = xfile ;
           afd->current_open += 1 ;
       }
       else if(afd->current_open < afd->max_open)
       {
           afd->tail->next = xfile ;
           afd->tail = xfile ;
           afd->current_open += 1 ;
       }
       else
       {
           cout<<"The open file is too many ! " <<endl ;
           return false ;
       }
   }
   else
   {
       cout<<"the "<<file_name<<" is not exit !"<<endl ;
       return false ;
   }
}

bool closeFile(AFD *afd , char file_name[])
{
    File *file = NULL  , *preFile = NULL  , *temp = NULL ;
    //在打开文件链表中进行查找
    file = afd->head ;
    while(file)
    {
        if(strcmp(file->file_name , file_name) == 0)
        {
            if(file == afd->head)
            {
                if(file == afd->tail)
                {
                    temp = file ;
                    afd->head = afd->tail = NULL ;
                }
                else
                {
                    temp = file ;
                    afd->head = file->next ;
                }
            }
            else if(file == afd->tail)
            {
                temp = file ;
                preFile->next = NULL ;
                afd->tail = preFile ;
            }
            else
            {
                temp =file ;
                preFile->next = file->next ;
            }
            delete temp ;
            return true ;
        }
        preFile = file ;
        file = file->next ;
    }
    cout<<"The file is not exit ! "<<endl ;
    return false ;
}

bool readFile(AFD *afd , char file_name[])
{
    File *file = NULL ;
    file = afd->head ;
    while(file)
    {
        if(strcmp(file->file_name , file_name) == 0)
        {
            if(file->open_file_protect[0])
            {
                file->read++ ;
                return true ;
            }
            else
            {
                cout<<"no read priority ! \n"<<endl ;
                return false ;
            }
        }
        file = file->next ;
    }
  cout<<"no such file ! "<<endl ;
  return false ;
}

bool writeFile(AFD *afd , char file_name[])
{
     File *file = NULL ;
    file = afd->head ;
    while(file)
    {
        if(strcmp(file->file_name , file_name) == 0)
        {
            if(file->open_file_protect[1])
            {
                file->write++ ;
                return true ;
            }
            else
            {
                cout<<"no write priority ! \n"<<endl ;
                return false ;
            }
        }
        file = file->next ;
    }
  cout<<"no such file ! "<<endl ;
  return false ;
}

void displayOpenFile(AFD *afd , Map *user)
{
    cout<<"The open file of "<<user->userName<<" : "<<endl ;
    File *file ;
    file = afd->head ;
    while(file)
    {
        cout<<file->file_name<<" "<<file->file_protect[0]<<" "<<file->file_protect[1]<<" "<<file->file_protect[2]<<" "<<file->file_length<<" " ;
        cout<<"readcout : "<<file->read<<" writecout : "<<file->write<<endl ;
        file = file->next ;
    }
}

四、测试结果

这里写图片描述

这里写图片描述

luo___ye
关注
  • 64
    点赞
  • 踩
  • 378
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
操作系统之文件系统设计一个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)
广东工业大学操作系统实验四文件系统
01-25
广东工业大学 操作系统 实验四 文件系统 一、实验目的 模拟文件系统实现的基本功能,了解文件系统的基本结构和文件的各种管理方法,加深理解文件系统的内部功能及内部实现。通过用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程，从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。 二、实验内容和要求 编程模拟一个简单的文件系统，实现文件系统的管理和控制功能。要求本文件系统采用 两级目录，即设置主文件目录[MFD]和用户文件目录[UED]。另外，为打开文件设置运行文件 目录[AFD]。设计一个10个用户的文件系统，每次用户可保存10个文件，一次运行用户可 以打开5个文件，并对文件必须设置保护措施。在用户程序中通过使用文件系统提供的Create、open、read、write、close、delete等文件命令，对文件进行操作。 …… …… ……
10个论坛
Sea_520的专栏
03-04 338
NO.1  http://community.csdn.net/      　　适合人群：软件开发者       　　特色：技术开发最全面的论坛，里面可以遇到很多牛人，版面也很全，什么J2EE，.NET啊，该有的全上，在这里基本上可以提出任何问题，人气也是最旺的，不过一般提出的意见都有正反两方面的，所以最终解决问题，还是得靠自己去把握。       　　评价：专业，很牛×，就是速度慢点。   
Linux操作系统之文件系统详解
热门推荐
m0_52165864的博客
08-22 2万+
文件系统是操作系统中负责管理持久数据的子系统，实际上，就是将用户的文件存放在磁盘硬件中，即使计算机断电了，磁盘里的数据并不会丢失，所以文件系统就可以持久化的保存文件。 文件系统是管理文件和目录的一套机制（方法）。文件大小为2T,ext3:不超过2T;fat32：4G。 文件系统的基本数据单位是文件，它主要是对磁盘上面的文件进行组织管理，组织的方式不同，形成的文件系统也会不同。
Intel VT-x 处于禁用状态【各电脑进入方法】
最新发布
【收录奇奇怪怪的电脑小知识】 原创来于生活
05-05 3620
Intel VT-x 处于禁用状态解决方案【各电脑进入方法】
Linux 文件系统详细解析
白话机器学习
08-30 2292
在 Linux 中，最直观、最可见的部分就是。下面我们就来一起探讨一下关于 Linux 中国的文件系统，系统调用以及文件系统实现背后的原理和思想。这些思想中有一些来源于 MULTICS，现在已经被 Windows 等其他操作系统使用。Linux 的设计理念就是。虽然 Linux 只是使用了最简单的机制和少量的系统调用，但是 Linux 却提供了强大而优雅的文件系统。
linux文件系统
123
07-06 1万+
，缩短 GNU/Linux 的开机时间。无论最下层的文件系统是什么，我们最上层的用户端尽管使用系统调用接口（open、write、read等）或glibc接口（fopen、fwrite、fread等）来操作就可访问文件系统里的文件，使得一切都是文件成为可能。/sys文件系统基本上包含了系统中所有设备的所有信息，比如制造商和型号、设备插入的位置、设备的状态、设备的层次结构等等。在我们嵌入式Linux中，NFS的主要应用如：把主机的上文件（比如目标板的可执行文件）共享给目标板，这样目标板就很方便地运行程序。
Linux文件系统概述
ARMCSKGT的博客
07-02 4959
简单介绍Linux系统中Ext文件系统的管理原理，以及机械硬盘的工作原理，帮助理解文件系统对于文件的管理方式！
【Linux】文件系统
gangaue的博客
11-30 1692
本篇文章进行操作系统中文件系统的学习！！！
基于C++实现模拟文件系统【100012421】
05-24
创建一个大约100M的文件作为模拟的硬盘，硬盘总空间分三个部分 超级块区: 1 * SuperBlk， inode区: 1024 * inode 磁盘块区 : 80 * 1024 * 磁盘块（1K） 超级块反映整个文件系统的空间分配情况，保存inode区的...
基于C/C++模拟处理机调度、存储管理（动态分区分配、分页存储地址转换）和文件系统.zip
05-09
基于C/C++模拟处理机调度、存储管理（动态分区分配、分页存储地址转换）和文件系统 基于C/C++模拟处理机调度、存储管理（动态分区分配、分页存储地址转换）和文件系统 基于C/C++模拟处理机调度、存储管理...
CPPfileSystem.rar_操作系统开发_C/C++_
08-11
在本项目中，"CPPfileSystem.rar"是一个包含C++代码的压缩文件，主要用于实现一个操作系统级别的文件系统模拟。这个课程设计旨在让学生深入理解操作系统如何管理和操作文件系统，通过使用C++这一强大的编程语言，来...
MyProjects.rar_操作系统开发_C/C++_
08-11
在这个"MyProjects.rar"压缩包中，我们可以期待找到一系列与操作系统开发相关的C/C++编程实践项目。C/C++语言因其高效、灵活和接近硬件的特性，常常被用来编写操作系统代码。 首先，让我们关注"进程管理"。在操作...
用java写的简单文件系统
11-14
用java写的简单文件系统,可以实现基本的文件系统操作,并赋有相关文挡和系统类图,欢迎批评指正.
os.zip_操作系统开发_C/C++_
08-11
在C或C++中实现操作系统功能需要深入理解底层机制，并且通常涉及汇编语言，以直接操作硬件寄存器。`os.cpp`文件很可能包含了这些概念的实现代码，可能包括了创建进程的函数、调度算法的实现、阻塞和唤醒操作的处理，...
此主机支持Intel VT-x,但Intel VT-x处于禁用状态
m0_63615119的博客
07-26 6293
在VMware Workstation中，启动虚拟机时，报“此主机支持Intel VT-x,但Intel VT-x处于禁用状态”错误提示，下面小编介绍如何解决这个问题，让虚拟机能正常启动
linux中的文件系统
转行笔记
12-14 1528
linux中的文件系统
用c/c++语言编写和调试一个简单的文件系统模拟文件管理的工作过程。
05-12
编写和调试一个简单的文件系统模拟，需要遵循以下步骤： 1. 设计文件系统的数据结构，如虚拟盘块、文件控制块（FCB）等。 2. 编写创建文件、删除文件、打开文件、关闭文件、读取文件、写入文件等文件操作函数，并将这些函数封装在单独的文件中。 3. 编写文件系统核心模块，实现对虚拟盘块的管理，如初始化虚拟盘块、分配和释放盘块，以及处理文件操作函数请求的调度和转发。 4. 编写测试代码，模拟文件系统的各种操作，并对代码进行测试、调试，修改不符合预期的结果。 在实现文件系统模拟的过程中，需要注意以下细节： 1. 数据结构设计应该充分考虑到文件系统的可扩展性和安全性。 2. 文件系统核心模块的编写需要严格控制各个模块的交互，减少出错的可能性。 3. 编写测试代码时需要覆盖尽可能多的边界情况和不合法的操作，以验证程序的正确性和鲁棒性。 以上就是用c/c语言编写和调试一个简单的文件系统模拟文件管理的工作过程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值