在外存中模拟分区分块的操作系统

#include<bits/stdc++.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <ctime>
#include <chrono>
#include <thread>
#include <mutex>
#include <condition_variable>
#include<map>
#include<conio.h>
#include <filesystem>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
using namespace std;

#define MAX_DISK_NUM 3   // 最多支持3个磁盘分区
#define MAX_PATH_LEN 256  // 最大路径长度
#define BLOCK_SIZE 1024    //块大小1024字节  64*1024*1024

int Current_disknum;
int FAT[64 * 1024];
int BLOCK_CNT = 1;
int sum; //磁盘有多少个文件 每用一次sum归0
int get_cnt = 0;
struct File {
    string creat_time; //创建时间
    string name;   // 文件名
    int size;         // 文件大小（字节数）
    vector<string> content;//文件内容
    int block_cnt;  //块号
};

struct Directory {
    string creat_time; //创建时间
    string name;   // 目录名
    int size;   //目录大小(字节数)
    Directory* parent;                // 父目录的节点
    map<string, File*> files;           // 所包含的文件
    map<string, Directory*> subDirs;         // 子目录
};

// 磁盘结构体
struct Disk {
    string name;        // 盘符
    int size;           // 分区大小（单位：MB）
    int start_block;    //起始块
    int block_num;
    int used_size;      // 已使用空间大小（单位：KB）
    //map<string, File*> files;       // 所包含的文件
    //map<string, Directory*> subDirs; //子目录
    Directory* root;//根目录
};

Disk disk[MAX_DISK_NUM];   // 磁盘数组
int current_disk = -1;      // 当前所在的磁盘编号
int* bitmap;//a盘用位示图

vector<string> records;//存放信息
Directory* curdir;//当前目录

string getTime()
{
    // 获取当前时间
    time_t t = time(nullptr);

    // 将时间转换为本地时间
    tm tm;
    localtime_s(&tm, &t);

    // 格式化时间为字符串
    char buffer[80];
    strftime(buffer, 80, "%Y-%m-%d-%H:%M", &tm);

    return string(buffer);
}

Directory* initDir(string name) {
    Directory* root = new Directory();
    root->name = name;
    root->creat_time = getTime();
    root->parent = NULL;
    return root;
}

void remove_sistem();

void InitDisk() {
    cout << "初始化硬盘命令：InitDisk  A xxM， B yyM, C zzM" << endl;
    string s;
    getline(cin, s);
    istringstream ss(s);
    vector<string> words;
    string word;
    while (ss >> word) {
        words.push_back(word);
    }
    int start = 0;
    int z;
    for (int i = 1, j = 0; i < words.size(); i += 2, j++) {
        disk[j].name = words[i];
        disk[j].used_size = 0;
        disk[j].start_block = start;
        if (j == 0) { disk[j].root = initDir("A#"); }
        if (j == 1) { disk[j].root = initDir("B#"); }
        if (j == 2) { disk[j].root = initDir("C#"); }
        string a = words[i + 1];
        string size = a.substr(0, 2);
        disk[j].size = atoi(size.c_str());
        disk[j].block_num = disk[j].size * 1024;
        start += disk[j].size * 1024;
        z = j;
    }
    Current_disknum = z;
    int temp = disk[0].block_num;
    bitmap = new int[temp]();//初始化为0
    current_disk = 0;
    curdir = disk[0].root;
}

void init() {
    ifstream inf("test.bin");
    if (!inf.is_open()) {
        ofstream outFile("test.bin", ios::binary | ios::out | ios::trunc);
        outFile.close();
    }

    memset(FAT, -1, sizeof(FAT));
    inf.seekg(0, ios::end);
    int size = inf.tellg();
    inf.close();
    //cout << size << endl;
    if (size < 10) {
        InitDisk();
    }
    else {
        current_disk = 0;//初始化并且把文件读入。
        remove_sistem();
        Current_disknum--;//remove_sistrm中计算磁盘数目多1 造成权限访问冲突
        BLOCK_CNT = disk[current_disk].used_size;
    }
    //InitDisk();
}

string displayPath(Directory* cur)
{
    string pathname = "";
    Directory* now = new Directory();
    now = cur;
    while (now)
    {
        string null;
        null = now->name;
        pathname = null + "\\" + pathname;
        now = now->parent;
    }

    return pathname;
}
void cnt_file(Directory* cur)
{
    for (auto& file : cur->files) {
        sum++;
    }
    for (auto& subDir : cur->subDirs) {
        cnt_file(subDir.second);
    }
}
void ChgDisk() {
    string name;
    cin >> name;
    for (int i = 0; i < MAX_DISK_NUM; i++) {
        if (disk[i].name.compare(name) == 0) {
            current_disk = i;
            curdir = disk[i].root;
            cnt_file(curdir);
            int cnt = sum;//定位
            sum = 0;
            BLOCK_CNT = disk[i].start_block + 1 + cnt;
        }
    }
}

void help() {

}

Directory* find_dir(string name, Directory* cur)//找到某目录下的指定目录
{
    for (auto& subDir : cur->subDirs) {
        if (subDir.second->name == name)
        {
            return subDir.second;
        }
    }
    return NULL;
}

File* find_file(string name, Directory* cur)
{
    for (auto& file : cur->files) {
        if (file.second->name == name)
        {
            return file.second;
        }
    }
    cout << "不存在该文件" << endl;
    return NULL;
}


void mkdir(Directory* cur, string name)
{
    Directory* now = cur;
    if (name.find('\\') != -1)//绝对路径
    {
        istringstream ss(name);
        string Substr;
        int i = 0;
        while (getline(ss, Substr, '\\'))
        {
            if (i == 0) {
                if (Substr.compare("A#") == 0) {
                    current_disk = 0;
                    now = disk[0].root;
                }
                if (Substr.compare("B#") == 0) {
                    current_disk = 1;
                    now = disk[1].root;
                }
                if (Substr.compare("C#") == 0) {
                    current_disk = 2;
                    now = disk[2].root;
                }
                i++;
            }
            else {
                int flag = 0;
                for (auto& subDir : now->subDirs) {//是否已有路径文件夹,确保绝对路径不会覆盖已有的路径文件夹。
                    if (subDir.second->name == Substr)
                    {
                        now = find_dir(Substr, now);
                        flag = 1;
                    }
                }
                if (flag == 0) {
                    Directory* New = new Directory();
                    New->creat_time = getTime();
                    New->size = 0;
                    New->name = Substr;
                    New->parent = now;
                    now->subDirs[Substr] = New;
                    now = find_dir(Substr, now);
                }
            }
        }
    }
    else {
        //相对路径
        for (auto& subDir : cur->subDirs) {//防止名字重复
            if (subDir.second->name == name)
            {
                name = name + "-1";
            }
        }
        Directory* New = new Directory();
        New->creat_time = getTime();
        New->name = name;
        New->parent = cur;
        cur->subDirs[name] = New;
    }
}
void deldir(Directory* cur, string name)
{
    Directory* now = cur;
    if (name.find('\\') != -1)//绝对路径
    {
        istringstream ss(name);
        string Substr;
        int i = 0;
        while (getline(ss, Substr, '\\'))
        {
            if (i == 0) {
                if (Substr.compare("A#") == 0) {
                    current_disk = 0;
                    now = disk[0].root;
                }
                if (Substr.compare("B#") == 0) {
                    current_disk = 1;
                    now = disk[1].root;
                }
                if (Substr.compare("C#") == 0) {
                    current_disk = 2;
                    now = disk[2].root;
                }
                i++;
            }
            else {
                now = find_dir(Substr, now);
                if (!now) {//不存在
                    cout << "未找到该文件夹！" << endl;
                    return;
                }
            }
        }
        Directory* temp = now->parent;
        if (now->size == 0) {
            temp->subDirs.erase(now->name);
            cout << "删除成功" << endl;
        }
        else {
            cout << "目录非空" << endl;
        }
    }
    else {
        now = find_dir(name, cur);
        if (!now) {
            cout << "未找到该文件夹！" << endl;
            return;
        }
        if (now->size == 0) {
            cur->subDirs.erase(now->name);
            cout << "删除成功" << endl;
        }
        else {
            cout << "该目录非空！" << endl;
        }
    }
}

void dir(Directory* cur, string name)
{
    if (name == "1") {
        cout << "子目录如下：" << endl;
        for (auto& subDir : cur->subDirs) {
            cout << subDir.second->name << "  创建时间：" << subDir.second->creat_time << " 文件大小：" << subDir.second->size << endl;
        }
        for (auto& files : cur->files) {
            cout << files.second->name << "  创建时间：" << files.second->creat_time << " 文件大小：" << files.second->size << "文件地址：" << files.second->block_cnt << endl;
        }
        cout << endl;
    }
    else {
        Directory* now = cur;
        istringstream ss(name);
        string Substr;
        int i = 0;
        while (getline(ss, Substr, '\\'))
        {
            if (i == 0) {
                if (Substr.compare("A#") == 0) {
                    current_disk = 0;
                    now = disk[0].root;
                }
                if (Substr.compare("B#") == 0) {
                    current_disk = 1;
                    now = disk[1].root;
                }
                if (Substr.compare("C#") == 0) {
                    current_disk = 2;
                    now = disk[2].root;
                }
                i++;
            }
            else {
                now = find_dir(Substr, now);
                if (!now) { cout << "该路径不存在"; return; }
            }
        }
        cout << "子目录如下：" << endl;
        for (auto& subDir : now->subDirs) {
            cout << subDir.second->name << "  创建时间：" << subDir.second->creat_time << " 文件大小：" << subDir.second->size << endl;
        }
        for (auto& files : now->files) {
            cout << files.second->name << "  创建时间：" << files.second->creat_time << " 文件大小：" << files.second->size << endl;
        }
        cout << endl;
    }
}

void chgdir(Directory* cur, string name)
{
    if (name == "..")//如果是输入..，返回父节点
    {
        if (cur->parent)
        {
            curdir = cur->parent;
        }
        return;
    }
    Directory* now = cur;
    if (name.find("\\") != -1)//如果是路径输入，则按照路径方式查找
    {
        istringstream ss(name);
        string Substr;
        int i = 0;
        while (getline(ss, Substr, '\\'))
        {
            if (i == 0) {
                if (Substr.compare("A#") == 0) {
                    current_disk = 0;
                    now = disk[0].root;
                }
                if (Substr.compare("B#") == 0) {
                    current_disk = 1;
                    now = disk[1].root;
                }
                if (Substr.compare("C#") == 0) {
                    current_disk = 2;
                    now = disk[2].root;
                }
                i++;
            }
            else {
                now = find_dir(Substr, now);
                if (!now) { cout << "该路径不存在" << endl; return; }
            }
        }
        curdir = now;
        return;
    }
    else {
        for (auto& subDir : cur->subDirs) {//直接在当前目录下查找
            if (subDir.second->name == name)
            {
                curdir = subDir.second;
                return;
            }

        }
        cout << "该目录不存在" << endl;
    }
}
Directory* jiexi(string name) {
    Directory* now = NULL;
    istringstream ss(name);
    string Substr;
    int i = 0;
    while (getline(ss, Substr, '\\'))
    {
        if (i == 0) {
            if (Substr.compare("A#") == 0) {
                current_disk = 0;
                now = disk[0].root;
            }
            if (Substr.compare("B#") == 0) {
                current_disk = 1;
                now = disk[1].root;
            }
            if (Substr.compare("C#") == 0) {
                current_disk = 2;
                now = disk[2].root;
            }
            i++;
        }//A#\b\c\d.txt
        else {
            if (Substr.find(".") == -1) {//对目录 now指向该目录，对文件，now指向它所处目录。
                now = find_dir(Substr, now);
                if (!now) { cout << "该路径不存在" << endl; return NULL; }
            }
        }
    }
    return now;
}

void movedir(Directory* cur, string name)
{
    istringstream s(name);
    vector<string> words;
    string word;
    while (s >> word) {
        words.push_back(word);
    }
    if (words[0].find("\\") == -1 && words[1].find("\\") != -1) //0相对路径 1绝对
    {
        Directory* temp = find_dir(words[0], cur);
        if (!temp) {
            cout << "未找到该文件夹！" << endl;
            return;
        }
        Directory* now = jiexi(words[1]);
        if (now == NULL) { return; }
        for (auto& subDir : now->subDirs) {//防止名字重复
            if (subDir.second->name == temp->name)
            {
                Directory* New = new Directory();
                *New = *temp;
                now->subDirs[New->name + "-1"] = New;
            }
        }
        Directory* New = new Directory();
        *New = *temp;
        now->subDirs[New->name] = New;
        deldir(cur, words[0]);
    }
    else if (words[1].find("\\") != -1 && words[0].find("\\") == -1)//0绝对 1相对
    {
        Directory* now = jiexi(words[0]);
        if (now == NULL) { return; }
        for (auto& subDir : cur->subDirs) {//防止名字重复
            if (subDir.second->name == now->name)
            {
                Directory* New = new Directory();
                *New = *now;
                cur->subDirs[New->name + "-1"] = New;
            }
        }
        Directory* New = new Directory();
        *New = *now;
        cur->subDirs[New->name + "-1"] = New;
        deldir(cur, words[0]);
    }
    else {
        Directory* now_0 = jiexi(words[0]);
        Directory* now_1 = jiexi(words[1]);
        if (now_0 == NULL || now_1 == NULL) { return; }
        Directory* New = new Directory();
        *New = *now_0;
        for (auto& subDir : now_1->subDirs) {//防止名字重复
            if (subDir.second->name == New->name)
            {
                now_1->subDirs[New->name + "-1"] = New;
            }
        }
        now_1->subDirs[New->name] = New;
    }
}
string getname(string name) {//获取绝对路径中的文件名
    if (name.find("\\") != -1) {//绝对路径
        istringstream ss(name);
        string word;
        string s;
        while (getline(ss, word, '\\')) {
            s = word;
        }
        return s;
    }
}

void create(Directory* cur, string name)
{

    if (name.find('\\') != -1)//绝对路径
    {
        Directory* now = jiexi(name);
        File* New = new File();
        New->size = 0;
        New->creat_time = getTime();
        for (auto& files : now->files) {
            if (files.second->name == getname(name))
            {
                name = getname(name) + "-1";
            }
        }
        New->name = getname(name);
        now->files[getname(name)] = New;
        New->block_cnt = BLOCK_CNT;
        FAT[BLOCK_CNT] = 0;
        BLOCK_CNT++;
    }
    else {
        //相对路径
        File* New = new File();
        New->size = 0;
        New->creat_time = getTime();
        for (auto& files : cur->files) {
            if (files.second->name == name)
            {
                name = name + "-1";
            }
        }
        New->name = name;
        cur->files[name] = New;
        New->block_cnt = BLOCK_CNT;
        FAT[BLOCK_CNT] = 0;
        BLOCK_CNT++;
    }
}

void Delete(Directory* cur, string name)
{
    if (name.find('\\') != -1)//绝对路径
    {
        Directory* now = jiexi(name);
        now->files.erase(getname(name));
        cout << "删除成功" << endl;
        /*for (auto& files : now->files) {
            if (files.second->name == getname(name))
            {
                now->files.erase(getname(name));
                cout << "删除成功" << endl;
            }
        }*/

    }
    else {
        //相对路径
       /* for (auto it = cur->files.begin(); it != cur->files.end();) {
            if (it->second->name == name) {
                cur->files.erase(it);
            }
        }Debug X和Release √*/
        File* now = find_file(name, cur);
        cur->files.erase(now->name);
        cout << "删除成功" << endl;
        /*for (auto& files : cur->files) {
            if (files.second->name == now->name)
            {
                cur->files.erase(name);
                cout << "删除成功" << endl;
            }
        }*/

    }
}

void copy(Directory* cur, string name)
{
    istringstream s(name);
    vector<string> words;
    string word;
    while (s >> word) {
        words.push_back(word);
    }
    if (words[0].find("\\") == -1 && words[1].find("\\") != -1) //0相对路径 1绝对  当前路径下文件复制到别的地方
    {
        File* temp = find_file(words[0], cur);
        if (!temp) {
            cout << "未找到该文件夹！" << endl;
            return;
        }
        Directory* now = jiexi(words[1]);
        if (now == NULL) { return; }

        File* New = new File();
        *New = *temp;
        for (auto& file : now->files) {//防止名字重复
            if (file.second->name == temp->name)
            {
                cout << "已存在该文件，重命名扣1，覆盖扣2" << endl;
                string a; cin >> a;
                string na;
                if (a == "1") {
                    cin >> na;
                }
                now->files[na] = New;
            }
        }
        now->files[New->name] = New;
    }
    else if (words[1].find("\\") != -1 && words[0].find("\\") == -1)//0绝对 1相对
    {
        Directory* now = jiexi(words[0]);
        if (now == NULL) { return; }
        File* temp = find_file(getname(words[0]), now);
        File* New = new File();
        *New = *temp;
        for (auto& file : cur->subDirs) {//防止名字重复
            if (file.second->name == getname(words[0]))
            {
                cout << "已存在该文件，重命名扣1，覆盖扣2" << endl;
                string a; cin >> a;
                string na;
                if (a == "1") {
                    cin >> na;
                }
                cur->files[na] = New;
            }
        }
        cur->files[New->name] = New;
    }
    else {
        Directory* now_0 = jiexi(words[0]);
        Directory* now_1 = jiexi(words[1]);
        File* no0 = find_file(getname(words[0]), now_0);
        if (now_0 == NULL || now_1 == NULL || no0 == NULL) { return; }
        File* New = new File();
        *New = *no0;
        for (auto& file : now_1->files) {//防止名字重复
            if (file.second->name == New->name)
            {
                cout << "已存在该文件，重命名扣1，覆盖扣2" << endl;
                string a; cin >> a;
                string na;
                if (a == "1") {
                    cin >> na;
                }
                now_1->files[na] = New;
            }
        }
        now_1->files[New->name] = New;
    }
}
int input(File* cur)
{
    string in;
    // 输入exit 结束输入
    int sum1 = cur->size;
    int sum2 = sum1;
    while (true) {
        getline(cin, in);
        if (in == "exit") {
            break;
        }
        cur->content.push_back(in);
        sum1 = sum1 + in.size();
    }
    cur->size = sum1;
    return sum1 - sum2;
}

void write(Directory* cur, string name)
{
    if (name.find("\\") == -1) {//相对路径
        File* f = find_file(name, cur);
        if (!f) return;
        Directory* temp = cur;
        int a = input(f);
        while (temp)
        {
            temp->size += a;
            temp = temp->parent;
        }
    }
    else {//绝对路径
        Directory* now = jiexi(name);
        File* f = find_file(getname(name), now);
        if (!now || !f) return;
        Directory* temp = now;
        int a = input(f);
        while (temp)
        {
            temp->size += a;
            temp = temp->parent;
        }
    }
}

void read(Directory* cur, string name)
{
    if (name.find("\\") == -1) {//相对路径
        File* f = find_file(name, cur);
        if (!f) { return; }
        for (auto tmp : f->content) {
            cout << tmp << endl;
        }
    }
    else {
        Directory* now = jiexi(name);
        File* f = find_file(getname(name), now);
        if (!now || !f) return;
        for (auto tmp : f->content) {
            cout << tmp << endl;
        }
    }
}

void Export(Directory* cur, string name)
{
    istringstream s(name);
    vector<string> words;
    string word;
    while (s >> word) {
        words.push_back(word);
    }
    if (words[0].find("\\") == -1 && words[1].find("\\") != -1) //0相对路径 1绝对  当前路径下文件复制到外存
    {
        File* temp = find_file(words[0], cur);
        if (!temp) {
            cout << "未找到该文件夹！" << endl;
            return;
        }
        string name2 = words[1] + "\\" + words[0];
        ofstream inr(name2);
        for (auto it = temp->content.begin(); it != temp->content.end(); it++)
        {
            inr << *it << endl;
        }
        inr.close();
    }
    else if (words[1].find("\\") != -1 && words[0].find("\\") != -1)//都相对
    {
        File* temp = find_file(words[0], cur);
        if (!temp) {
            cout << "未找到该文件夹！" << endl;
            return;
        }
        ofstream inr(words[1]);
        for (auto it = temp->content.begin(); it != temp->content.end(); it++)
        {
            inr << *it << endl;
        }
        inr.close();
    }
    else if (words[1].find("\\") != -1 && words[0].find("\\") == -1)//0绝对 1相对
    {
        Directory* now = jiexi(words[0]);
        if (now == NULL) { return; }
        File* temp = find_file(getname(words[0]), now);
        ofstream inr(words[1]);
        for (auto it = temp->content.begin(); it != temp->content.end(); it++)
        {
            inr << *it << endl;
        }
        inr.close();
    }
    else {
        Directory* now_0 = jiexi(words[0]);
        File* temp = find_file(getname(words[0]), now_0);
        if (now_0 == NULL || temp == NULL) { return; }
        string name2 = words[1] + "\\" + getname(words[0]);
        ofstream inr(name2);
        for (auto it = temp->content.begin(); it != temp->content.end(); it++)
        {
            inr << *it << endl;
        }
        inr.close();
    }
}
void ShowDisk(string name)
{
    /*for (int i = 0; i < MAX_DISK_NUM; i++) {
        if (disk[i].name.compare(name) == 0) {
            current_disk = i;
            cnt_file(disk[current_disk].root);
            int cnt = sum;//定位
            sum = 0;
            disk[current_disk].used_size = (cnt + 1);
            break;
        }
    }*/
    cout << "空间总大小：" << disk[current_disk].size << "MB" << endl;
    cout << "已用空间大小：" << disk[current_disk].used_size << "KB" << endl;
    cout << "可用空间大小：" << disk[current_disk].size * 1024 - disk[current_disk].used_size << "KB" << endl;
}

void used_cnt()
{
    for (int i = 0; i <= Current_disknum; i++) {
        cnt_file(disk[i].root);
        int cnt = sum;//定位
        sum = 0;
        disk[i].used_size = (cnt + 1);
    }
}

void put(Directory* cur, ofstream& inr, int i)
{
    inr << cur->name << " " << cur->size << " " << cur->creat_time << " ";
    for (auto& subDirs : cur->subDirs) {//将子文件夹所包含的文件夹名称写入
        inr << subDirs.second->name << " ";
        //inr << subDirs.second->size << " ";
        //inr << subDirs.second->creat_time << " ";
    }
    inr << endl;
    for (auto& files : cur->files) {//将子文件及其内容写入文件
        inr << files.second->name << " " << files.second->size << " " << files.second->creat_time << " " << files.second->block_cnt - disk[i].start_block << endl;
    }
    streampos pos = inr.tellp();
    for (auto& files : cur->files) {
        int a = files.second->block_cnt * 1024;
        inr.seekp(a, ios::beg);
        inr << "begin" << endl;
        for (auto it = files.second->content.begin(); it != files.second->content.end(); it++)//文件内容
        {
            inr << *it << endl;
        }
        inr << "exit" << endl;
    }
    inr.seekp(pos, ios::beg);
    for (auto& subDirs : cur->subDirs) {
        put(subDirs.second, inr, i);
    }
}

void remove_disk()
{
    ofstream inr("test.bin", ios::binary | ios::out | ios::trunc);
    inr << Current_disknum << endl;
    for (int i = 0; i <= Current_disknum; i++)
    {
        int a = disk[i].start_block * BLOCK_SIZE;
        inr.seekp(a, ios::beg);
        inr << disk[i].name << " " << disk[i].size << " " << disk[i].start_block << " " << disk[i].block_num << " " << disk[i].used_size << endl;
        put(disk[i].root, inr, i);
    }
    inr.close();
}

Directory* path(Directory* cur, string name)//获得所需要文件的节点或者文件夹的所在目录的节点。
{
    for (auto& files : cur->files) {
        if (files.second->name == name)
        {
            return cur;
        }
    }
    Directory* now;
    for (auto& subDirs : cur->subDirs) {
        if (subDirs.second->name == name)
        {
            return subDirs.second;
        }
        now = path(subDirs.second, name);
        if (now)
        {
            return now;
        }
    }
    return NULL;
}

string trims(const string& str) {
    size_t first = str.find_first_not_of(" \t\n\r\f\v");
    if (first == string::npos) {
        return "";
    }
    size_t last = str.find_last_not_of(" \t\n\r\f\v");
    return str.substr(first, last - first + 1);
}

string trim(const string& str) {
    size_t start = 0;
    size_t end = str.length();

    // 寻找第一个非空字符的位置
    while (start < end && str[start] == '\0'|| start < end && str[start] == 32) {
        start++;
    }

    // 寻找最后一个非空字符的位置
    while (end > start && str[end - 1] == '\0' || start < end && str[start] == 32) {
        end--;
    }

    // 返回除去两边空字符后的子串
    return str.substr(start, end - start);
}


void remove_sistem()
{
    ifstream inr("test.bin");
    string temp;

    while (getline(inr, temp)) {
        temp = trim(temp);
        if (!temp.empty()) {
            records.push_back(temp);
        }
    }
    inr.close();

    /*for (int i = 0; i < records.size(); i++)
    {
        if (records[i].length() == 0) { records[i] = "begin"; }
        cout << records[i] << endl;
    }
    /*for (int i = 0; i < records.size(); i++)
    {
        cout << records[i] <<i<< endl;
    }*/
    /*先读第一个书 循环初始化*/
    disk[0].root = initDir("A#");
    disk[1].root = initDir("B#");
    //disk[2].root = initDir("C#"); 
    curdir = disk[0].root;

    int p = 0;
    Directory* now = NULL;
    int num_disk = 0;
    for (int i = 0; i < records.size(); i++)
    {
        string s = records[i];
        istringstream ss(s);
        string substr;
        int nnn = 0;
        if (nnn == 0)
        {
            //int p = 0;
            if (p == 0)
            {
                int bj = 0;
                while (getline(ss, substr, ' '))
                {
                    if (bj == 0) {
                        disk[num_disk].name = substr;
                        p++;
                    }
                    if (bj == 1) {
                        disk[num_disk].size = stoi(substr);
                        p++;
                    }
                    if (bj == 2) {
                        disk[num_disk].start_block = stoi(substr);
                        p++;
                    }
                    if (bj == 3) {
                        disk[num_disk].block_num = stoi(substr);
                        p++;
                    }
                    if (bj == 4) {
                        disk[num_disk].used_size = stoi(substr);
                        p++;
                    }
                    bj++;
                }
            }
            else
            {
                int chishu = 0;
                while (getline(ss, substr, ' '))
                {
                    if (substr.find('.') == -1)
                    {//如果是目录
                        if (substr.find(disk[num_disk].name) != -1)
                        {//是不是根目录
                            now = disk[num_disk].root;
                        }
                        else
                        {
                            now = path(disk[num_disk].root, substr);
                        }
                        now->name = substr;
                        string txt;
                        int n = 0;
                        while (getline(ss, txt, ' '))
                        {
                            if (n == 0) {
                                now->size = stoi(txt);
                                n++;
                            }
                            else if (n == 1) {
                                now->creat_time = txt;
                                n++;
                            }
                            else {
                                mkdir(now, txt);
                            }
                        }
                    }
                    else
                    {//如果是文件
                        create(now, substr);
                        get_cnt++;//------------------------------------  dengyu used_size-1  直接跳到B
                        File* cur = now->files[substr];
                        string txt;
                        int n = 0;
                        while (getline(ss, txt, ' '))
                        {
                            if (n == 0) {
                                cur->size = stoi(txt);
                                n++;
                            }
                            else if (n == 1) {
                                cur->creat_time = txt;
                                n++;
                            }
                            else
                            {
                                int pos = stoi(txt);
                                cur->block_cnt = pos + disk[num_disk].start_block;
                                int z = 0;
                                for (int j = i; j < records.size(); j++)
                                {
                                    if (records[j].find("begin") != -1) { z++; }
                                    if (z == pos) {
                                        for (int k = j + 1; k < records.size(); k++) {
                                            if (records[k].compare("exit") == 0) { break; }
                                            cur->content.push_back(records[k]);
                                        }
                                        break;
                                    }
                                }

                            }
                        }
                    }
                }
            }
        }
        if (get_cnt == disk[num_disk].used_size - 1)
        {
            int pos = get_cnt;
            int z = 0;
            Current_disknum++;
            for (int j = i; j < records.size(); j++)
            {
                if (records[j].find("exit") != -1) { z++; }
                if (z == pos) {
                    i = j;
                    num_disk++;
                    get_cnt = 0;
                    p = 0;
                    break;
                }
            }
        }
    }
}

void tree(Directory* cur,int n)
{
    for (auto& files : cur->files) {
        for (int i = 0; i < n; i++) { cout << "\t"; }
        cout << files.second->name << endl;
    }
    for (auto& subDirs : cur->subDirs) {
        for (int i = 0; i < n; i++) { cout << "\t"; }
        cout << subDirs.second->name << "------" << endl;
        tree(subDirs.second,n+1);
    }
}
int main() {
    init();
    while (1)
    {
        /*if (current_disk == 0)cout << "A#";
        else if(current_disk==1)cout << "B#";
        else if(current_disk==2)cout<< "C#";
        else {
            cout << endl;
            cout << "不存在该盘" << endl;
        }*/
        cout << displayPath(curdir);
        string command;
        cin >> command;
        if (command == "ChgDisk") ChgDisk();
        else if (command == "MKDir") { string name; cin >> name; mkdir(curdir, name); cout << "创建成功" << endl; }
        else if (command == "DelDir") { string name; cin >> name; deldir(curdir, name); }
        else if (command == "Dir") { cout << "输入1表示当前目录，查看其它目录请输入路径:" << endl; string name; cin >> name; dir(curdir, name); }
        else if (command == "ChgDir") { string name; cin >> name; chgdir(curdir, name); }
        else if (command == "MoveDir") { string name; getline(cin, name); movedir(curdir, name); }
        else if (command == "Create") { string name; cin >> name; create(curdir, name); }
        else if (command == "Delete") { string name; cin >> name; Delete(curdir, name); }
        else if (command == "Copy") { string name; getline(cin, name); copy(curdir, name); }//no accomplish
        else if (command == "Write") { string name; cin >> name; write(curdir, name); }
        else if (command == "Read") { string name; cin >> name; read(curdir, name); }
        else if (command == "Export") { string name; getline(cin, name); Export(curdir, name); }
        else if (command == "ShowDisk") { string name; cin >> name; ShowDisk(name); }
        else if (command == "TreeDir") { tree(curdir,0); }
        else if (command == "time") { cout << getTime() << endl; }
        //else if (command == "cnt") { cnt_file(curdir); cout << sum << endl; }
        else if (command == "exit") {
            break;
        }
        else {
            cout << "命令无法识别，请参照一下提示进行输入：\n";
            help();
        }
        used_cnt();
        remove_disk();
    }
    return 0;
}