C语言实现简单文件系统，支持多级目录

本程序使用 C语言模拟实现了一个简单的文件系统，支持多级目录、文件创建、文件打开等基本功能。

程序代码：

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>

int physic[300];        // 文件地址缓冲区，用于存储文件的物理地址
int style=1;            // 文件的类型，1表示文本文件，2表示二进制文件

char cur_dir[10]="c";   // 当前目录，初始值为"c"

struct command         // 命令结构体
{
    char com[10];       // 命令名称
}cmd[12];

struct block           // 盘块结构体，用于模拟磁盘的存储空间 
{
    int n;              // 空闲的盘块的个数
    int free[50];       // 存放空闲盘块的地址
    int a;              // 模拟盘块是否被占用，0表示未被占用，1表示被占用
}memory[200];

struct block_super     // 超级块结构体，用于存储空闲盘块的信息 
{
    int n;              // 空闲的盘块的个数
    int free[50];       // 存放进入栈中的空闲块
    int stack[50];      // 存放下一组空闲盘块的地址
}super_block;

struct node             // i结点结构体，用于存储文件的相关信息
{
    int file_style;     // i结点文件类型，1表示文本文件，2表示二进制文件
    int file_length;    // i结点文件长度，即文件占用的盘块数
    int file_address[100];  // i结点文件的物理地址，即文件所占用的盘块的地址
} i_node[64];

struct dir              // 目录项结构体，用于存储文件的目录信息
{
    char file_name[10]; // 文件名
    int  i_num;         // 文件的结点号
    char dir_name[10];  // 文件所在的目录
} c[64];

void format()           // 格式化函数，用于初始化文件系统
{
    int i,j,k;
    super_block.n=50;   // 超级块中空闲盘块的个数初始值为50
    for(i=0;i<50;i++)   // 初始化超级块
    {
        super_block.free[i]=i;
        super_block.stack[i]=50+i;
    }

    for(i=0;i<64;i++)   // 初始化i结点信息
    {
        for(j=0;j<100;j++)
        {
            i_node[i].file_address[j]=-1;
        }
        i_node[i].file_length=-1;
        i_node[i].file_style=-1;
    }

    for(i=0;i<64;i++)   // 初始化根目录区信息
    {
        strcpy(c[i].file_name,"");
        c[i].i_num=-1;
        strcpy(c[i].dir_name,"");
    }

    for(i=0;i<200;i++)  // 初始化存储空间
    {
        memory[i].n=0;
        memory[i].a=0;
        for(j=0;j<50;j++)
        {
            memory[i].free[j]=-1;
        }
    }

    for(i=0;i<200;i++)  // 将空闲块的信息用成组链接的方法写进每组的最后一个块中
    {                   // 存储空间初始化
        if((i+1)%50==0) // 每50个盘块为一组
        {
            k=i+1;
            for(j=0;j<50;j++)
            {
                if(k<200)
                {
                    memory[i].free[j]=k;
                    memory[i].n++;
                    k++;
                }
                else
                {
                    memory[i].free[j]=-1;
                }
            }
            memory[i].a=0;
            continue;
        }
        for(j=0;j<50;j++)
        {
            memory[i].free[j]=-1;
        }
        memory[i].n=0;
    }
    printf("已经初始化完毕\n");
    printf("欢迎进入UNIX文件模拟系统！！！\n\n");
}

void write_file(FILE *fp)    /* 将信息读入系统文件中 */
{
 int i;
 fp=fopen("system","wb");
 for(i=0;i<200;i++)
 {
  fwrite(&memory[i],sizeof(struct block),1,fp);
 }
 fwrite(&super_block,sizeof(struct block_super),1,fp);

 for(i=0;i<64;i++)
 {
 fwrite(&i_node[i],sizeof(struct node),1,fp);
 }
 for(i=0;i<64;i++)
 {
 fwrite(&c[i],sizeof(struct dir),1,fp);
 }
 fclose(fp);
}

void read_file(FILE *fp)   /* 读出系统文件的信息 */
{
 int i;
 fp=fopen("system","rb");
 for(i=0;i<200;i++)
 {
  fread(&memory[i],sizeof(struct block),1,fp);
 }

 fread(&super_block,sizeof(struct block_super),1,fp);

 for(i=0;i<64;i++)
 {
  fread(&i_node[i],sizeof(struct node),1,fp);
 }

 for(i=0;i<64;i++)
 {
  fread(&c[i],sizeof(struct dir),1,fp);
 }
 fclose(fp);
}

void callback(int length)    /* 回收磁盘空间 */
{
 int i,j,k,m,q=0;
 for(i=length-1;i>=0;i--)
 {
  k=physic[i];
  m=49-super_block.n;
  if(super_block.n==50)
  {
   for(j=0;j<50;j++)
   {
    memory[k].free[j]=super_block.free[j];
   }
   super_block.n=0;
   memory[k].n=50;
  }
  memory[k].a=0;
  if(m==-1)
  {
   m=49;
  }
  super_block.free[m]=physic[i];
  super_block.n++;
 }
}

void allot(int length)     /* 分配空间 */
{
 int i,j,k,m,p;
 for(i=0;i<length;i++)
 {
  k=50-super_block.n;
  m=super_block.free[k];
  p=super_block.free[49];
  if(m==-1||memory[p].a==1)
  {
   printf("内存不足,不能够分配空间\n");
   callback(length);
   break;
  }
  if(super_block.n==1)
  {
   memory[m].a=1;
   physic[i]=m;
   super_block.n=0;
   for(j=0;j<memory[m].n;j++)
   {
    super_block.free[j]=memory[m].free[j];
    super_block.n++;
   }
   continue;
  }
  physic[i]=m;
  memory[m].a=1;
  super_block.n--;
 }
}

void create_file(char filename[],int length) /* 创建文件 */
{
 int i,j;
 for(i=0;i<64;i++)
 {
  if(strcmp(filename,c[i].file_name)==0)
  {
   printf("文件已经存在，不允许建立重名的文件\n");
   return;
  }
 }
 for(i=0;i<64;i++)
 {
   if(c[i].i_num==-1)
   {
    c[i].i_num=i;
    strcpy(c[i].file_name,filename);
    strcpy(c[i].dir_name,cur_dir);
    i_node[i].file_style=style;
    i_node[i].file_length=length;
    allot(length);
    for(j=0;j<length;j++)
    {
     i_node[i].file_address[j]=physic[j];
    }
    break;
   }
 }
}

void create_dir(char filename[])    /* 创建目录 */
{
 style=0;
 create_file(filename,4);
 style=1;
}

// ... (其他功能函数，如open_file，read_file等)

int main()
{
    format();
    // ... (调用其他功能函数，实现文件系统功能)
    return 0;
}

多级目录支持:

本程序支持多级目录。在目录项结构体中有一个成员变量 dir_name，用于存储文件所在的目录名。因此可以通过在目录名中加入 / 符号来实现多级目录的创建和操作。例如，可以通过以下方式创建多级目录：

create_dir("dir1/dir2/dir3");

其中，/ 符号表示目录的层级关系。在程序中，会自动将目录名分割成多个子目录，并在相应的目录中创建文件。

同时，在操作文件时，也可以通过指定目录名来访问多级目录中的文件。例如：

open_file("dir1/dir2/file.txt");

注意:

本程序只是一个简单的文件系统模拟，功能有限。实际的系统会更加复杂，并需要考虑更多因素，例如安全性、效率等。

程序功能说明：

format()：初始化文件系统，分配磁盘空间并设置超级块、i结点和目录项等信息。
write_file()：将内存中的文件系统信息写入到磁盘文件中。
read_file()：从磁盘文件中读取文件系统信息到内存中。
callback()：回收磁盘空间。
allot()：分配磁盘空间。
create_file()：创建一个文件，并分配相应的磁盘空间。
create_dir()：创建一个目录，本质上是创建一个长度为4的特殊文件。
open_file()：打开一个文件，用于后续的读写操作。
read_file()：读取文件内容。
write_file()：写入文件内容。
delete_file()：删除文件，回收相应的磁盘空间。
delete_dir()：删除目录。

运行步骤:

将代码保存为 file_system.c 文件。
使用 GCC 编译器编译代码：gcc file_system.c -o file_system
运行可执行文件：./file_system

使用示例：

// 初始化文件系统
format();

// 创建文件
create_file("file1.txt", 10);

// 创建目录
create_dir("dir1");

// 创建多级目录
create_dir("dir1/dir2");

// 在目录中创建文件
create_file("dir1/file2.txt", 5);

// ... (其他操作)

本程序代码仅供参考，可根据实际需求进行修改和完善。