《计算机操作系统》第七章 - 文件管理

一、前言

大家好！今天我们来系统梳理《计算机操作系统》第七章 “文件管理” 的核心知识点，从基础概念到代码实现，力求通俗易懂，每个核心知识点都会搭配实战案例和架构图 / 流程图，帮助大家彻底吃透文件管理的底层逻辑。所有代码均采用C++98 标准编写，可直接编译运行，注释详尽，方便动手实操。

二、核心知识点讲解

7.1 文件和文件系统

1. 核心概念

文件：是操作系统中存储信息的基本单位，由一系列字符 / 字节组成，具有唯一文件名，存储在外部存储介质（磁盘、U 盘等）上。文件系统：是操作系统中负责管理和存储文件信息的软件集合，核心功能包括文件创建 / 删除、读写、目录管理、权限控制等。

2. 架构图

3. 实战案例：模拟文件系统基础结构（C++98）

#include <iostream> #include <string> #include <ctime> using namespace std; // 遵循C++98标准，模拟文件的基本属性和操作 // 文件属性结构体（对应文件系统中文件的元数据） struct FileAttribute { string fileName; // 文件名 int fileSize; // 文件大小（字节） time_t createTime; // 创建时间 time_t modifyTime; // 修改时间 string fileType; // 文件类型（文本/二进制等） }; // 文件系统基础类 class FileSystem { public: // 构造函数：初始化文件系统 FileSystem() { cout << "文件系统初始化完成！" << endl; } // 创建文件：初始化文件属性 void createFile(const string& name, const string& type, int size) { FileAttribute file; file.fileName = name; file.fileSize = size; file.fileType = type; // 获取当前时间作为创建/修改时间（先赋值给变量，再取地址） file.createTime = time(NULL); file.modifyTime = file.createTime; cout << "文件创建成功！" << endl; cout << "文件名：" << file.fileName << endl; cout << "文件大小：" << file.fileSize << " 字节" << endl; cout << "文件类型：" << file.fileType << endl; cout << "创建时间：" << ctime(&file.createTime); } // 删除文件 void deleteFile(const string& name) { cout << "文件 " << name << " 删除成功！" << endl; } // 读取文件（模拟） void readFile(const string& name) { cout << "正在读取文件：" << name << endl; cout << "文件内容（模拟）：Hello, File System!" << endl; } // 写入文件（模拟）- 修复临时值取地址问题 void writeFile(const string& name, const string& content) { cout << "向文件 " << name << " 写入内容：" << content << endl; // 修复点：先将time(NULL)的结果赋值给变量（左值），再取地址 time_t currentTime = time(NULL); cout << "文件修改时间更新为：" << ctime(&currentTime); } }; // 主函数：测试文件系统基础操作 int main() { // 创建文件系统实例 FileSystem fs; // 创建文本文件 fs.createFile("test.txt", "文本文件", 1024); // 读取文件 fs.readFile("test.txt"); // 写入文件 fs.writeFile("test.txt", "这是测试文件的内容！"); // 删除文件 fs.deleteFile("test.txt"); return 0; }

4. 代码说明

• 定义FileAttribute结构体模拟文件元数据（文件名、大小、时间等），对应文件系统中存储的文件属性；
• FileSystem类封装文件系统核心操作（创建、删除、读写），符合 C++98 语法规范；
• 主函数中完成完整的文件操作流程，可直接编译运行（g++ -std=c++98 文件名.cpp -o 可执行文件）。

7.2 文件的逻辑结构

1. 核心概念

文件的逻辑结构是用户视角下文件的组织形式，分为两类：

• 流式文件：无结构，由字符 / 字节流组成（如.txt 文件）；
• 记录式文件：有结构，由多条记录组成（如数据库表、CSV 文件）。

2. 流程图

3. 实战案例：模拟流式文件和记录式文件（C++98）

#include <iostream> #include <string> #include <vector> #include <iomanip> using namespace std; // 遵循C++98标准，模拟两种文件逻辑结构 // 1. 流式文件类（无结构，字节流） class StreamFile { private: string fileName; string content; // 字节流形式存储内容 public: StreamFile(const string& name) : fileName(name) {} // 写入字节流（流式文件核心操作） void writeStream(const string& data) { content += data; // 直接追加，无结构限制 cout << "流式文件 " << fileName << " 写入成功，当前内容长度：" << content.size() << " 字节" << endl; } // 读取字节流 string readStream() { cout << "读取流式文件 " << fileName << " 内容：" << endl; return content; } }; // 2. 记录式文件：单条记录结构体 struct Record { int id; // 记录ID string name; // 姓名 int age; // 年龄 }; // 记录式文件类 class RecordFile { private: string fileName; vector<Record> records; // 按记录组织内容（C++98支持vector） public: RecordFile(const string& name) : fileName(name) {} // 添加记录（记录式文件核心操作，有固定结构） void addRecord(int id, const string& name, int age) { Record r; r.id = id; r.name = name; r.age = age; records.push_back(r); cout << "记录式文件 " << fileName << " 添加记录成功，当前记录数：" << records.size() << endl; } // 读取指定记录 Record readRecord(int id) { for (vector<Record>::iterator it = records.begin(); it != records.end(); ++it) { // C++98迭代器写法 if (it->id == id) { cout << "找到记录 ID=" << id << "：" << endl; return *it; } } cout << "未找到记录 ID=" << id << endl; return Record(); // 返回空记录 } // 打印所有记录 void printAllRecords() { cout << "记录式文件 " << fileName << " 所有记录：" << endl; cout << setw(5) << "ID" << setw(10) << "姓名" << setw(5) << "年龄" << endl; for (vector<Record>::iterator it = records.begin(); it != records.end(); ++it) { cout << setw(5) << it->id << setw(10) << it->name << setw(5) << it->age << endl; } } }; // 主函数：测试两种文件逻辑结构 int main() { // 1. 测试流式文件 StreamFile sFile("stream.txt"); sFile.writeStream("Hello, Stream File!"); sFile.writeStream("这是流式文件的追加内容，无结构限制。"); cout << sFile.readStream() << endl << endl; // 2. 测试记录式文件 RecordFile rFile("record.csv"); rFile.addRecord(1, "张三", 20); rFile.addRecord(2, "李四", 22); rFile.printAllRecords(); Record r = rFile.readRecord(1); cout << "读取到的记录：ID=" << r.id << "，姓名=" << r.name << "，年龄=" << r.age << endl; return 0; }

4. 代码说明

• 流式文件类StreamFile：通过字符串直接存储字节流，写入时无结构限制，模拟.txt 等无结构文件；
• 记录式文件类RecordFile：通过vector存储固定结构的Record结构体，模拟 CSV / 数据库表等有结构文件；
• 全部采用 C++98 语法（如迭代器写法、无 C++11 的 auto 关键字），可直接编译运行。

7.3 文件目录

1. 核心概念

文件目录（文件夹）是操作系统为管理文件而建立的索引结构，核心作用是映射文件名和文件物理存储地址，常见结构：

• 单级目录：所有文件存于一个目录，无层级；
• 两级目录：分为用户目录和文件目录；
• 树形目录（最常用）：多级层级结构（如 Windows 的 C:\Users\XXX）。

2. 思维导图

3. 实战案例：模拟树形文件目录（C++98）

#include <iostream> #include <string> #include <vector> using namespace std; // 遵循C++98标准，模拟树形文件目录结构 // 目录节点类（可包含文件或子目录） class DirNode { private: string name; // 目录/文件名 bool isDir; // 是否为目录（true=目录，false=文件） DirNode* parent; // 父目录指针 vector<DirNode*> children; // 子节点（文件/子目录） public: // 构造函数：初始化节点 DirNode(const string& name, bool isDir, DirNode* parent) : name(name), isDir(isDir), parent(parent) {} // 析构函数：释放子节点内存（C++98手动管理内存） ~DirNode() { for (vector<DirNode*>::iterator it = children.begin(); it != children.end(); ++it) { delete *it; } } // 添加子节点（文件/子目录） void addChild(const string& childName, bool isChildDir) { DirNode* child = new DirNode(childName, isChildDir, this); children.push_back(child); cout << (isChildDir ? "目录" : "文件") << " " << childName << " 创建成功！" << endl; } // 遍历当前目录下的所有节点 void listChildren() { cout << "当前目录 " << name << " 下的内容：" << endl; for (vector<DirNode*>::iterator it = children.begin(); it != children.end(); ++it) { cout << ((*it)->isDir ? "[目录] " : "[文件] ") << (*it)->name << endl; } } // 查找子节点（返回指针，用于进入子目录） DirNode* findChild(const string& childName) { for (vector<DirNode*>::iterator it = children.begin(); it != children.end(); ++it) { if ((*it)->name == childName && (*it)->isDir) { return *it; } } cout << "未找到目录 " << childName << endl; return NULL; } // 获取当前节点名称 string getName() { return name; } }; // 主函数：模拟树形目录操作（如Linux/macOS的cd、ls、mkdir、touch） int main() { // 1. 创建根目录（/） DirNode* root = new DirNode("/", true, NULL); DirNode* currentDir = root; // 当前工作目录 // 2. 在根目录创建子目录和文件 currentDir->addChild("home", true); // 创建home目录 currentDir->addChild("etc", true); // 创建etc目录 currentDir->addChild("readme.txt", false); // 创建readme.txt文件 currentDir->listChildren(); cout << "------------------------" << endl; // 3. 进入home目录 currentDir = currentDir->findChild("home"); cout << "当前目录切换到：" << currentDir->getName() << endl; // 4. 在home目录创建用户目录和文件 currentDir->addChild("user1", true); // 创建user1目录 currentDir->addChild("user2", true); // 创建user2目录 currentDir->addChild("profile.cfg", false); // 创建配置文件 currentDir->listChildren(); // 5. 释放内存 delete root; return 0; }

4. 代码说明

• DirNode类模拟目录节点，包含名称、类型（目录 / 文件）、父节点、子节点列表；
• 实现添加子节点、遍历目录、切换目录等核心操作，模拟树形目录的层级管理；
• 手动管理内存（析构函数释放子节点），符合 C++98 的内存管理规范。

7.4 文件共享

1. 核心概念

文件共享是指多个用户 / 进程同时访问同一个文件，常见实现方式：

• 基于索引节点（i 节点）：多个目录项指向同一个 i 节点（存储文件元数据）；
• 符号链接（软链接）：创建指向原文件的快捷方式；
• 硬链接：多个文件名指向同一物理存储。

2. 流程图

3. 实战案例：模拟文件共享（C++98）

#include <iostream> #include <string> #include <map> using namespace std; // 遵循C++98标准，模拟文件共享（i节点+硬链接+软链接） // 模拟i节点（存储文件元数据，不存储文件名） struct INode { string fileData; // 文件实际内容 int linkCount; // 硬链接计数 string filePath; // 文件物理路径 }; // 文件共享管理器 class FileShareManager { private: map<int, INode> inodeMap; // i节点表（i节点ID→i节点） map<string, int> fileNameToInode;// 文件名→i节点ID（硬链接） map<string, string> symLinkMap; // 软链接表（链接名→原文件名） int nextInodeId; // 下一个可用i节点ID public: FileShareManager() : nextInodeId(1) {} // 创建文件，初始化i节点 void createFile(const string& fileName, const string& data) { INode inode; inode.fileData = data; inode.linkCount = 1; inode.filePath = "/disk/" + fileName; int inodeId = nextInodeId++; inodeMap[inodeId] = inode; fileNameToInode[fileName] = inodeId; cout << "文件 " << fileName << " 创建成功，i节点ID：" << inodeId << endl; } // 创建硬链接：新增文件名→同一i节点 void createHardLink(const string& linkName, const string& origName) { if (fileNameToInode.find(origName) == fileNameToInode.end()) { cout << "原文件 " << origName << " 不存在！" << endl; return; } int inodeId = fileNameToInode[origName]; fileNameToInode[linkName] = inodeId; inodeMap[inodeId].linkCount++; // 硬链接计数+1 cout << "硬链接 " << linkName << " 指向 " << origName << " 创建成功！" << endl; cout << "当前i节点 " << inodeId << " 硬链接数：" << inodeMap[inodeId].linkCount << endl; } // 创建软链接：存储原文件路径（不关联i节点） void createSymLink(const string& linkName, const string& origName) { if (fileNameToInode.find(origName) == fileNameToInode.end()) { cout << "原文件 " << origName << " 不存在！" << endl; return; } symLinkMap[linkName] = origName; cout << "软链接 " << linkName << " 指向 " << origName << " 创建成功！" << endl; } // 读取文件（支持硬链接/软链接）- 修复const参数修改问题 void readFile(const string& fileName) { // 修复点：创建临时变量存储文件名，避免修改const参数 string actualFileName = fileName; // 1. 先判断是否是软链接 if (symLinkMap.find(actualFileName) != symLinkMap.end()) { string origName = symLinkMap[actualFileName]; cout << "软链接 " << actualFileName << " 指向原文件：" << origName << endl; actualFileName = origName; // 修改临时变量，而非const参数 } // 2. 判断是否是硬链接/原文件 if (fileNameToInode.find(actualFileName) == fileNameToInode.end()) { cout << "文件 " << actualFileName << " 不存在！" << endl; return; } int inodeId = fileNameToInode[actualFileName]; cout << "读取文件 " << actualFileName << "（i节点ID：" << inodeId << "）内容：" << endl; cout << inodeMap[inodeId].fileData << endl; } // 删除文件（硬链接计数为0时才真正删除i节点） void deleteFile(const string& fileName) { if (fileNameToInode.find(fileName) == fileNameToInode.end()) { cout << "文件 " << fileName << " 不存在！" << endl; return; } int inodeId = fileNameToInode[fileName]; fileNameToInode.erase(fileName); // 删除文件名映射 inodeMap[inodeId].linkCount--; // 硬链接计数-1 cout << "文件 " << fileName << " 已删除，当前i节点 " << inodeId << " 硬链接数：" << inodeMap[inodeId].linkCount << endl; // 硬链接计数为0，删除i节点 if (inodeMap[inodeId].linkCount == 0) { inodeMap.erase(inodeId); cout << "i节点 " << inodeId << " 已释放！" << endl; } } }; // 主函数：测试文件共享 int main() { FileShareManager fsm; // 1. 创建原文件 fsm.createFile("data.txt", "这是共享文件的内容！"); // 2. 创建硬链接 fsm.createHardLink("data_hardlink.txt", "data.txt"); // 3. 创建软链接 fsm.createSymLink("data_symlink.txt", "data.txt"); // 4. 读取硬链接/软链接 cout << "------------------------" << endl; fsm.readFile("data_hardlink.txt"); cout << "------------------------" << endl; fsm.readFile("data_symlink.txt"); // 5. 删除原文件（硬链接仍可用） cout << "------------------------" << endl; fsm.deleteFile("data.txt"); fsm.readFile("data_hardlink.txt"); // 硬链接仍可读取 // 6. 删除硬链接（i节点释放） cout << "------------------------" << endl; fsm.deleteFile("data_hardlink.txt"); // 7. 软链接失效 cout << "------------------------" << endl; fsm.readFile("data_symlink.txt"); return 0; }

4. 代码说明

• 用INode结构体模拟 i 节点，存储文件实际内容和硬链接计数；
• 硬链接：多个文件名映射到同一 i 节点 ID，计数 > 0 时文件不真正删除；
• 软链接：单独存储链接名→原文件名，原文件删除则链接失效；
• 全部操作符合 C++98 标准，模拟 Linux 系统的文件共享逻辑。

7.5 文件保护

1. 核心概念

文件保护是防止文件被未授权访问 / 修改，常见方式：

• 访问控制列表（ACL）：为每个文件指定用户 / 组的访问权限（读 R、写 W、执行 X）；
• 口令保护：访问文件需输入口令；
• 加密保护：文件内容加密存储，只有解密后才能访问。

2. 架构图

3. 实战案例：模拟文件权限保护（C++98）

#include <iostream> #include <string> #include <map> using namespace std; // 遵循C++98标准，模拟文件访问权限保护（ACL） // 用户类型枚举（C++98支持enum） enum UserType { OWNER, // 文件所有者 GROUP, // 同组用户 OTHER // 其他用户 }; // 文件权限结构体 struct FilePermission { bool read; // 读权限 bool write; // 写权限 bool exec; // 执行权限 // C++98兼容：添加默认构造函数（避免初始化问题） FilePermission() : read(false), write(false), exec(false) {} // 带参数的构造函数（方便初始化） FilePermission(bool r, bool w, bool e) : read(r), write(w), exec(e) {} }; // 文件保护管理器 class FileProtectManager { private: // 修复点1：C++98要求嵌套模板的>>必须分开写为> > map<string, map<UserType, FilePermission> > permMap; // 用户-文件所有者映射 map<string, string> userFileOwnerMap; // 模拟用户口令 map<string, string> userPwdMap; public: // 初始化：添加测试用户和口令 FileProtectManager() { userPwdMap["user1"] = "123456"; // 文件所有者 userPwdMap["user2"] = "654321"; // 同组用户 userPwdMap["user3"] = "000000"; // 其他用户 } // 创建文件并设置权限（所有者默认拥有全部权限） void createFileWithPerm(const string& fileName, const string& owner) { // 记录文件所有者 userFileOwnerMap[fileName] = owner; // 设置所有者权限（R/W/X）- 使用C++98的构造函数初始化 FilePermission ownerPerm(true, true, true); // 设置同组用户权限（R/X） FilePermission groupPerm(true, false, true); // 设置其他用户权限（仅R） FilePermission otherPerm(true, false, false); permMap[fileName][OWNER] = ownerPerm; permMap[fileName][GROUP] = groupPerm; permMap[fileName][OTHER] = otherPerm; cout << "文件 " << fileName << " 创建成功！" << endl; cout << "所有者：" << owner << endl; cout << "权限设置：" << endl; cout << " 所有者：读(R)=是，写(W)=是，执行(X)=是" << endl; cout << " 同组用户：读(R)=是，写(W)=否，执行(X)=是" << endl; cout << " 其他用户：读(R)=是，写(W)=否，执行(X)=否" << endl; } // 用户登录验证 bool userLogin(const string& userName, const string& pwd) { if (userPwdMap.find(userName) == userPwdMap.end()) { cout << "用户 " << userName << " 不存在！" << endl; return false; } if (userPwdMap[userName] != pwd) { cout << "口令错误！" << endl; return false; } cout << "用户 " << userName << " 登录成功！" << endl; return true; } // 判断用户对文件的权限 FilePermission checkPerm(const string& userName, const string& fileName) { if (permMap.find(fileName) == permMap.end()) { cout << "文件 " << fileName << " 不存在！" << endl; // 修复点2：使用C++98的构造函数返回空权限，而非列表初始化 return FilePermission(false, false, false); } // 判断用户类型 string owner = userFileOwnerMap[fileName]; UserType ut; if (userName == owner) { ut = OWNER; } else if (userName == "user2") { // 模拟同组用户 ut = GROUP; } else { ut = OTHER; } cout << "用户 " << userName << " 对文件 " << fileName << " 的权限类型：" << (ut == OWNER ? "所有者" : (ut == GROUP ? "同组用户" : "其他用户")) << endl; return permMap[fileName][ut]; } // 执行文件操作（检查权限） void doFileOperation(const string& userName, const string& fileName, const string& op) { FilePermission perm = checkPerm(userName, fileName); bool allowed = false; if (op == "read" && perm.read) { allowed = true; } else if (op == "write" && perm.write) { allowed = true; } else if (op == "exec" && perm.exec) { allowed = true; } if (allowed) { cout << "允许执行 " << op << " 操作！" << endl; } else { cout << "拒绝执行 " << op << " 操作：权限不足！" << endl; } } }; // 主函数：测试文件保护 int main() { FileProtectManager fpm; // 1. 创建文件，指定所有者为user1 fpm.createFileWithPerm("app.exe", "user1"); cout << "------------------------" << endl; // 2. 用户1登录，测试所有操作 if (fpm.userLogin("user1", "123456")) { fpm.doFileOperation("user1", "app.exe", "read"); fpm.doFileOperation("user1", "app.exe", "write"); fpm.doFileOperation("user1", "app.exe", "exec"); } cout << "------------------------" << endl; // 3. 用户2（同组）登录，测试操作 if (fpm.userLogin("user2", "654321")) { fpm.doFileOperation("user2", "app.exe", "read"); fpm.doFileOperation("user2", "app.exe", "write"); // 无写权限 fpm.doFileOperation("user2", "app.exe", "exec"); } cout << "------------------------" << endl; // 4. 用户3（其他）登录，测试操作 if (fpm.userLogin("user3", "000000")) { fpm.doFileOperation("user3", "app.exe", "read"); fpm.doFileOperation("user3", "app.exe", "write"); // 无写权限 fpm.doFileOperation("user3", "app.exe", "exec"); // 无执行权限 } return 0; }

4. 代码说明

• 用UserType枚举区分用户类型（所有者 / 同组 / 其他），FilePermission存储 R/W/X 权限；
• FileProtectManager实现用户登录、权限检查、操作鉴权核心逻辑；
• 模拟不同用户的权限差异，符合操作系统中文件权限管理的核心思想。

三、习题

基础题

1. 简述文件的逻辑结构分类及各自特点，结合 7.2 的代码说明流式文件和记录式文件的实现差异。
2. 解释硬链接和软链接的区别，结合 7.4 的代码说明为何硬链接删除原文件后仍可访问，而软链接不行。
3. 操作系统中文件目录的核心作用是什么？树形目录相比单级目录有哪些优势？

编程题

基于 7.5 的文件保护代码，扩展功能：

1. 添加 “修改文件权限” 的函数，允许文件所有者修改同组 / 其他用户的 R/W/X 权限；
2. 增加 “用户组管理” 功能，支持将用户加入 / 移出指定组，动态判断用户权限类型。

四、代码运行说明

1. 编译命令（确保编译器支持 C++98）：

g++ -std=c++98 文件名.cpp -o 可执行文件名

1. 运行命令：

./可执行文件名 # Linux/macOS # 或 可执行文件名.exe # Windows

1. 所有代码无第三方依赖，仅依赖 C++98 标准库，可直接编译运行。

总结

1. 文件管理核心包括文件 / 文件系统基础、逻辑结构、目录管理、共享、保护五大模块，每个模块均对应操作系统的核心功能；
2. 实战代码基于 C++98 标准实现，模拟了各模块的核心逻辑（如树形目录、i 节点共享、ACL 权限控制），可直接编译运行；
3. 各知识点配套架构图 / 流程图（Mermaid 格式），可直接复制到 Mermaid 编辑器生成可视化图形，辅助理解概念。