文件系统模拟：连续分配与离散分配实现

本代码使用 C 语言模拟一个简单的文件系统，实现了两种文件空间分配方式：连续分配和离散分配。

代码实现:

#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
using namespace std;

int map[100][100];

typedef struct file
{
    char    fileName[30];   /* 文件名字 */
    int     length;         /* 文件长度 */
    int     start;          /* 文件存储时 的初始位置 */
}file;

file    File[60];
int     line, column;           /* 行  列 */
int     fileTotalNum = 0;       /* 总文件数 */


/*
* *函数名：mapInit()
* *描述： 对位示图进行初始化
* *参数： 无
* *返回值： 无
**/
void  mapInit()
{
    int i, j;
    printf( "请输入行和列：" );
    scanf( "%d%d", &line, &column );
    for ( i = 0; i < line; i++ )
    {
        for ( j = 0; j < column; j++ )
        {
            map[i][j] = 0;
            printf( "%3d", map[i][j] );
        }
        printf( "\n" );
    }
}


/*
* *函数名：allocation(int fileNum, bool isContinuous)
* *描述： 分配空间给文件，采用连续分配方式或离散分配方式
* *参数： fileNum  第几个文件
          isContinuous 是否采用连续分配方式
* *返回值： 无
**/
void  allocation( int fileNum, bool isContinuous )
{
    int length = File[fileNum].length;
    int b[60];
    int i, j;
    int x = 0;
    if (isContinuous) { // 连续分配方式
        for (i = 0; i < line; i++)
        {
            for (j = 0; j < column; j++)
            {
                if (map[i][j] == 0)
                {
                    b[x] = i * column + j;
                    x++;
                    if (x == length)
                        break;  /* 这个 break ,跳出 j　循环 */
                }
                else
                    x = 0;
            }
            if (x == length)
                break;                  /* 这里 break, 跳出整个 for循环体 */
        }
    }
    else { // 离散分配方式
        for (i = 0; i < length; i++) {
            int x, y;
            printf("请输入第%d个盘块的行列坐标：", i + 1);
            scanf("%d%d", &x, &y);
            if (x >= 0 && x < line && y >= 0 && y < column && map[x][y] == 0) {
                b[i] = x * column + y;
            }
            else {
                printf("输入的坐标不合法或该盘块已被占用，请重新输入\n");
                i--;
            }
        }
    }
    if (length > x)
        printf( "空间不足，无法分配\n" );
    else {
        File[fileNum].start = b[0];
        for (int i = 0; i < x; i++)
        {
            int x1 = b[i] / column;
            int y1 = b[i] % column;
            map[x1][y1] = 1; /* 置1  代表使用 过 */
        }
    }
    for (i = 0; i < line; i++)
    {
        for (j = 0; j < column; j++)
        {
            printf("%3d", map[i][j]);
        }
        printf("\n");
    }
}


/*
* *函数名：recovery(char s[])
* *描述：  通过文件名回收文件占用空间，并将位示图中对应标志位重新初始化为0
* *参数： char s[]  文件名
* *返回值： 无
**/
void recovery( char s[] )
{
    int cnt = -1;
    for ( int i = 0; i < fileTotalNum; i++ )
    {
        if ( strcmp( s, File[i].fileName ) == 0 )
        {
            cnt = i; /* 记录下  第几个 文件 */
            break;
        }
    }
    if ( cnt == -1 )
    {
        printf( "没有此文件，请重新输入!\n" );
    }
    int start = File[cnt].start;
    int length = File[cnt].length;
    for ( int i = start; i < start + length; i++ )
    {
        int x1 = i / column;
        int y1 = i % column;
        map[x1][y1] = 0;
    }
    for ( int i = cnt + 1; i < fileTotalNum; i++ ) /*删除文件后 将其后面的文件前移  覆盖原来文件 */
    {
        strcpy( File[i - 1].fileName, File[i].fileName );
        File[i - 1].start = File[i].start;
        File[i - 1].length = File[i].length;
    }
    printf( "回收成功\n" );
    for ( int i = 0; i < line; i++ )
    {
        for ( int j = 0; j < column; j++ )
        {
            printf( "%3d", map[i][j] );
        }
        printf( "\n" );
    }
    fileTotalNum--;
}


int main()
{
    int i, j, n;
    int flag;
    bool isContinuous;  /* 是否采用连续分配方式 */
    mapInit();
    while ( true )
    {
        printf( "请选择操作：\n" );
        printf( "1. 创建文件\n" );
        printf( "2. 回收文件\n" );
        scanf( "%d", &n );
        switch ( n )
        {
        case 1:
            printf( "请输入文件名：\n" );
            scanf( "%s", File[fileTotalNum].fileName );
            printf( "请输入文件长度：\n" );
            scanf( "%d", &File[fileTotalNum].length );
            printf( "请选择分配方式：\n" );
            printf( "1. 连续分配\n" );
            printf( "2. 离散分配\n" );
            scanf( "%d", &flag );
            isContinuous = (flag == 1);
            allocation( fileTotalNum, isContinuous );
            fileTotalNum++;
            break;
        case 2:
            printf( "请输入文件名：\n" );
            char s[30];
            scanf( "%s", s );
            recovery( s );
            break;
        default:
            printf( "输入错误！\n" );
            break;
        }
    }
    return 0;
}

运行实例:

1. 连续分配:

请输入行和列：3 5
  0  0  0  0  0
  0  0  0  0  0
  0  0  0  0  0
请选择操作：
1. 创建文件
2. 回收文件
1
请输入文件名：
file1
请输入文件长度：
3
请选择分配方式：
1. 连续分配
2. 离散分配
1
  0  0  0  0  1
  0  0  0  1  1
  0  0  0  0  0
请选择操作：
1. 创建文件
2. 回收文件
1
请输入文件名：
file2
请输入文件长度：
2
请选择分配方式：
1. 连续分配
2. 离散分配
1
  0  0  0  0  1
  0  0  0  1  1
  1  1  0  0  0

2. 离散分配:

请输入行和列：3 5
  0  0  0  0  0
  0  0  0  0  0
  0  0  0  0  0
请选择操作：
1. 创建文件
2. 回收文件
1
请输入文件名：
file1
请输入文件长度：
3
请选择分配方式：
1. 连续分配
2. 离散分配
2
请输入第1个盘块的行列坐标：0 0
请输入第2个盘块的行列坐标：1 2
请输入第3个盘块的行列坐标：2 4
  1  0  0  0  0
  0  0  1  0  0
  0  0  0  0  1
请选择操作：
1. 创建文件
2. 回收文件
2
请输入文件名：
file1
回收成功
  0  0  0  0  0
  0  0  0  0  0
  0  0  0  0  0

代码说明:

map 数组是一个二维数组，用于模拟磁盘空间，0 表示空闲，1 表示已分配。
File 数组用于存储文件信息，包括文件名、文件长度和文件起始位置。
mapInit() 函数用于初始化 map 数组，用户输入磁盘的行数和列数。
allocation() 函数根据用户选择的方式分配空间：
- 连续分配：从磁盘空间中寻找连续的空闲块，分配给文件。
- 离散分配：用户输入每个文件块的坐标，分配给文件。
recovery() 函数通过文件名回收文件空间，并将 map 数组中的对应位重置为 0。
main() 函数用于用户交互，创建文件和回收文件。

改进建议:

可以使用链表等数据结构来管理文件信息，更方便地进行文件插入和删除。
可以添加更多功能，例如文件读取和写入、目录操作等。
可以增加错误处理，例如文件已存在、空间不足等情况。
可以将代码封装成更具模块化的结构，提高代码的可读性和可维护性。

总结:

本代码模拟了简单的文件系统，实现了连续分配和离散分配两种空间分配方式，并提供文件创建和回收功能。代码简单易懂，可以帮助理解文件系统的基本原理。