1.假设这个文件系统工作在一个128KB的磁盘上，只有一个根目录，没有子目录。 2.文件系统最多支持16个文件。一个文件最多有8个块，块的大小是1KB。 3.每个文件有一个独一无二的文件名，文件名长度不超过8个字符。 4.128KB的磁盘的布局如下： (1)第1个1KB是超级块，存储空闲块链表和每个文件的i节点。超级块的结构如下： 前128字节保存空闲块链表，如果第i个字节为0，表明这个块是空闲的。初始化时，除超级块外，所有的块都是空闲的。接着是16个i节点。每个i节点保存以下信息： char name[8]; //文件名 int size; // 文件大小（用文件块数表示） int blockPointers[8]; // 数据块指针 int used; // 0 => i节点空闲; 1 => i节点被使用。初始化时为0。 每个i节点大小为48字节，16个i节点总共为768字节。所以超级块实际上是896字节，但是我们仍然给它分配1KB。 (2)剩下的127KB存储文件的数据块。 5.文件系统要实现以下操作： (1)文件创建create(char name[8], int size) char name[8]: 文件名，int size:文件块数 假设文件创建以后大小不再改变。 (2)文件删除delete(char name[8]) (3)读文件read(char name[8], int blockNum, char buf[1024]) int blockNum:文件块号 (4)写文件write(char name[8], int blockNum, char buf[1024]) C++实现

以下是C++实现，其中使用了一个全局变量来表示超级块：

#include <iostream>
#include <cstring>
using namespace std;

const int BLOCK_SIZE = 1024;
const int BLOCK_NUM = 128;
const int MAX_FILE_NUM = 16;
const int MAX_FILE_NAME_LEN = 8;
const int MAX_FILE_BLOCK_NUM = 8;
const int MAX_FILE_SIZE = MAX_FILE_BLOCK_NUM * BLOCK_SIZE;
const int MAX_INODE_NUM = MAX_FILE_NUM;
const int MAX_INODE_SIZE = 48;
const int SUPER_BLOCK_SIZE = BLOCK_SIZE;
const int SUPER_BLOCK_FREE_BLOCK_LIST_SIZE = BLOCK_NUM / 8;

char disk[BLOCK_NUM][BLOCK_SIZE];
int freeBlockList[SUPER_BLOCK_FREE_BLOCK_LIST_SIZE];

struct Inode {
    char name[MAX_FILE_NAME_LEN];
    int size;
    int blockPointers[MAX_FILE_BLOCK_NUM];
    int used;
};

struct SuperBlock {
    int freeBlockList[SUPER_BLOCK_FREE_BLOCK_LIST_SIZE];
    Inode inodes[MAX_INODE_NUM];
};

SuperBlock superBlock;

void init() {
    memset(freeBlockList, 0, sizeof(freeBlockList));
    for (int i = 0; i < BLOCK_NUM; i++) {
        if (i == 0) {
            // 初始化超级块
            superBlock.freeBlockList[0] = 0x01;
            for (int j = 1; j < SUPER_BLOCK_FREE_BLOCK_LIST_SIZE; j++) {
                superBlock.freeBlockList[j] = 0x00;
            }
            for (int j = 0; j < MAX_INODE_NUM; j++) {
                superBlock.inodes[j].used = 0;
            }
        } else {
            // 初始化空闲块链表
            freeBlockList[i / 8] |= (0x01 << (i % 8));
        }
    }
}

int allocateBlock() {
    for (int i = 0; i < SUPER_BLOCK_FREE_BLOCK_LIST_SIZE; i++) {
        if (superBlock.freeBlockList[i] == 0xff) {
            continue;
        }
        for (int j = 0; j < 8; j++) {
            if ((superBlock.freeBlockList[i] & (0x01 << j)) == 0) {
                superBlock.freeBlockList[i] |= (0x01 << j);
                return i * 8 + j;
            }
        }
    }
    return -1;
}

void freeBlock(int blockNum) {
    superBlock.freeBlockList[blockNum / 8] &= ~(0x01 << (blockNum % 8));
}

int findInode(char name[MAX_FILE_NAME_LEN]) {
    for (int i = 0; i < MAX_INODE_NUM; i++) {
        if (superBlock.inodes[i].used && strcmp(superBlock.inodes[i].name, name) == 0) {
            return i;
        }
    }
    return -1;
}

int create(char name[MAX_FILE_NAME_LEN], int size) {
    int inodeNum = findInode(name);
    if (inodeNum >= 0) {
        return -1;  // 文件已存在
    }
    for (int i = 0; i < MAX_INODE_NUM; i++) {
        if (!superBlock.inodes[i].used) {
            inodeNum = i;
            superBlock.inodes[inodeNum].used = 1;
            strcpy(superBlock.inodes[inodeNum].name, name);
            superBlock.inodes[inodeNum].size = size;
            for (int j = 0; j < MAX_FILE_BLOCK_NUM; j++) {
                superBlock.inodes[inodeNum].blockPointers[j] = -1;
            }
            return inodeNum;
        }
    }
    return -1;  // 没有空闲的inode
}

int deleteFile(char name[MAX_FILE_NAME_LEN]) {
    int inodeNum = findInode(name);
    if (inodeNum < 0) {
        return -1;  // 文件不存在
    }
    for (int i = 0; i < MAX_FILE_BLOCK_NUM; i++) {
        int blockNum = superBlock.inodes[inodeNum].blockPointers[i];
        if (blockNum >= 0) {
            freeBlock(blockNum);
        }
    }
    superBlock.inodes[inodeNum].used = 0;
    return 0;
}

int read(char name[MAX_FILE_NAME_LEN], int blockNum, char buf[BLOCK_SIZE]) {
    int inodeNum = findInode(name);
    if (inodeNum < 0) {
        return -1;  // 文件不存在
    }
    if (blockNum < 0 || blockNum >= superBlock.inodes[inodeNum].size) {
        return -1;  // 块号不合法
    }
    int blockPtr = superBlock.inodes[inodeNum].blockPointers[blockNum];
    if (blockPtr < 0) {
        return -1;  // 数据块不存在
    }
    memcpy(buf, disk[blockPtr], BLOCK_SIZE);
    return 0;
}

int write(char name[MAX_FILE_NAME_LEN], int blockNum, char buf[BLOCK_SIZE]) {
    int inodeNum = findInode(name);
    if (inodeNum < 0) {
        return -1;  // 文件不存在
    }
    if (blockNum < 0 || blockNum >= superBlock.inodes[inodeNum].size) {
        return -1;  // 块号不合法
    }
    int blockPtr = superBlock.inodes[inodeNum].blockPointers[blockNum];
    if (blockPtr < 0) {
        blockPtr = allocateBlock();
        if (blockPtr < 0) {
            return -1;  // 磁盘空间不足
        }
        superBlock.inodes[inodeNum].blockPointers[blockNum] = blockPtr;
    }
    memcpy(disk[blockPtr], buf, BLOCK_SIZE);
    return 0;
}

int main() {
    init();
    int inodeNum = create("test.txt", 2);
    char buf[BLOCK_SIZE];
    for (int i = 0; i < BLOCK_SIZE; i++) {
        buf[i] = 'a' + i % 26;
    }
    for (int i = 0; i < 2; i++) {
        write("test.txt", i, buf);
    }
    char readBuf[BLOCK_SIZE];
    for (int i = 0; i < 2; i++) {
        read("test.txt", i, readBuf);
        for (int j = 0; j < BLOCK_SIZE; j++) {
            cout << readBuf[j];
        }
        cout << endl;
    }
    deleteFile("test.txt");
    return 0;
}