文件管理系统C语言codeblocks

赵屿 · 发表于前天 12:55

使用C语言在windows系统下的codeblocks，设计并实现一个文件系统
文件系统的功能要求如下：
（一）输入模块：接收信息进程，包括用户名，文件相关信息的接受收；通信进程，能够下发消息；
（二）文件系统进程模块：通信进程，能够上传回显，并且下发文件参数；文件参数控制进程，其中包括创建人，需要多大空间等；
（三）内存进程模块：内存模拟进程，要求每个十个字符当做占用一个内存页，模拟进程换入换出，每进出一次内存，输出到外存；每个内存页中实现，用一个数据结构申请空间并释放，当做一次换入换出；通过算法来完成要求；
（四）外存模拟进程，需要有设计文件查找模式，参数储存模式，和文件内容输出功能，并且能够保证通信进程的回传成功。

FishC · 发表于前天 13:03

以下是一个简单的文件管理系统的设计思路，使用C语言在Windows系统下的Code::Blocks中实现：

1. **输入模块**：
   - 创建一个函数用于接收用户输入，包括用户名和文件相关信息。
   - 使用`scanf`或`fgets`来获取用户输入。

2. **文件系统进程模块**：
   - 创建一个函数用于处理文件的上传和回显。
   - 使用文件I/O函数如`fopen`、`fwrite`、`fread`等来处理文件操作。
   - 设计一个结构体来存储文件参数，如创建人和所需空间。

3. **内存进程模块**：
   - 模拟内存页，每10个字符占用一个内存页。
   - 使用一个数组或链表来模拟内存页的分配和释放。
   - 实现一个简单的换入换出算法，如FIFO或LRU。

4. **外存模拟进程**：
   - 设计一个函数用于文件查找和参数存储。
   - 使用文件I/O函数来实现文件内容的输出。
   - 确保通信进程能够成功回传信息。

以下是一个简单的代码示例，展示如何实现文件的创建和写入：

[code]#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define PAGE_SIZE 10

typedef struct {
    char username[50];
    char filename[50];
    int fileSize;
} FileInfo;

void inputModule(FileInfo *fileInfo) {
    printf("请输入用户名: ");
    scanf("%s", fileInfo->username);
    printf("请输入文件名: ");
    scanf("%s", fileInfo->filename);
    printf("请输入文件大小: ");
    scanf("%d", &fileInfo->fileSize);
}

void fileSystemModule(FileInfo *fileInfo) {
    FILE *file = fopen(fileInfo->filename, "w");
    if (file == NULL) {
        printf("文件创建失败！
");
        return;
    }
    fprintf(file, "创建人: %s
", fileInfo->username);
    fprintf(file, "文件大小: %d
", fileInfo->fileSize);
    fclose(file);
    printf("文件创建成功！
");
}

int main() {
    FileInfo fileInfo;
    inputModule(&fileInfo);
    fileSystemModule(&fileInfo);
    return 0;
}

这个示例代码实现了一个简单的文件创建功能，用户可以输入用户名、文件名和文件大小，程序会创建一个文件并写入相关信息。根据你的需求，可以进一步扩展和完善其他模块。[/code]

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

赵屿 · 发表于前天 13:13

FishC 发表于 2024-12-19 13:03
这个示例代码实现了一个简单的文件创建功能，用户可以输入用户名、文件名和文件大小，程序会创建一个文 ...

要求能完成以下功能完整能运行代码（1）设置和修改用户对文件的存取权限的服务。（2）创建、改变和删除目录的服务（3）共享文件、设置访同路径的服务（4）创建、打开、读写、关闭以及删除文件的服务

FishC · 发表于前天 13:15

赵屿发表于 2024-12-19 13:13
要求能完成以下功能完整能运行代码（1）设置和修改用 ...

要实现一个完整的文件管理系统，包括用户权限管理、目录操作和文件操作的基本功能，以下是一个简化的示例代码。该代码着重展示了如何创建、修改文件权限，创建、删除目录，以及基本的文件操作。在实际开发中，需要更多的错误处理和安全考虑。

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

// 定义用户权限
typedef struct {
    char username[20];
    int readPermission;
    int writePermission;
} User;

// 检查用户权限（简化，不包括用户认证）
int checkPermission(User *user, int readRequired, int writeRequired) {
    return (user->readPermission >= readRequired) && (user->writePermission >= writeRequired);
}

// 设置和修改文件权限
void setFilePermissions(User *user, int read, int write) {
    user->readPermission = read;
    user->writePermission = write;
    printf("权限设置成功：读=%d 写=%d\n", read, write);
}

// 创建、删除目录服务
void createDirectory(const char *dirName) {
    if (mkdir(dirName) == 0) {
        printf("目录创建成功：%s\n", dirName);
    } else {
        perror("目录创建失败");
    }
}

void removeDirectory(const char *dirName) {
    if (rmdir(dirName) == 0) {
        printf("目录删除成功：%s\n", dirName);
    } else {
        perror("目录删除失败");
    }
}

// 创建、读写、删除文件服务
void createFile(const char *fileName) {
    FILE *file = fopen(fileName, "w");
    if (file) {
        printf("文件创建成功：%s\n", fileName);
        fclose(file);
    } else {
        perror("文件创建失败");
    }
}

void deleteFile(const char *fileName) {
    if (remove(fileName) == 0) {
        printf("文件删除成功：%s\n", fileName);
    } else {
        perror("文件删除失败");
    }
}

void writeFile(const char *fileName, const char *content) {
    FILE *file = fopen(fileName, "a");
    if (file) {
        fprintf(file, "%s", content);
        printf("写入成功：%s\n", content);
        fclose(file);
    } else {
        perror("写入失败");
    }
}

void readFile(const char *fileName) {
    char buffer[1024];
    FILE *file = fopen(fileName, "r");
    if (file) {
        while (fgets(buffer, sizeof(buffer), file)) {
            printf("%s", buffer);
        }
        printf("\n");
        fclose(file);
    } else {
        perror("读取失败");
    }
}

int main() {
    User user = {"admin", 1, 1};

    // 示例：设置权限
    setFilePermissions(&user, 1, 1);

    // 示例：目录操作
    createDirectory("testDir");
    removeDirectory("testDir");

    // 示例：文件操作
    createFile("testFile.txt");
    writeFile("testFile.txt", "Hello, world!\n");
    if (checkPermission(&user, 1, 0)) {
        readFile("testFile.txt");
    } else {
        printf("无权限读取文件\n");
    }
    deleteFile("testFile.txt");

    return 0;
}

**注意：**
- 此代码仅供教育参考，实际应用中需考虑多用户管理、确保权限安全。
- `mkdir` 和 `rmdir` 函数用于目录操作，适用于POSIX系统（如Linux）。在Windows上，需使用 `_mkdir` 和 `_rmdir` 或Windows API。
- "用户权限" 在该示例中为简化状态，可扩展添加用户认证和更细粒度权限控制。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

赵屿 · 发表于前天 14:02

FishC 发表于 2024-12-19 13:15
要实现一个完整的文件管理系统，包括用户权限管理、目录操作和文件操作的基本功能，以下是一个简化的示 ...

详细补充以下代码要求满足以下条件
（1）设置和修改用户对文件的存取权限的服务
（2）创建、改变和删除目录的服务
（3）共享文件、设置访同路径的服务
（4）创建、打开、读写、关闭以及删除文件的服务
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<string.h>
#define FILENAME_MAX 256
#define FOLDERNAME_MAX 256
#define FILELEN 1000

//用户的结构体
typedef struct USER
{
char name[100];       //用户名
int userRights;       //用户权限 0为最高级权限，3为最低级权限
char account[256];    //用户账号
char password[256];    //用户密码
int state;             //登录状态

}USER;

//文件的结构体
typedef struct
{
char name[FILENAME_MAX];    //文件名
char content[FILELEN];    //文件内容
struct FILES* frontFile;    //同级目录上一文件
struct FILES* nextFile;    //同级目录下一文件
struct FOLDERS* parentFolder;    //父目录
int canRead;    //是否可读
int canWrite;    //是否可写

} FILES;

//目录的结构体
typedef struct
{
char name[FOLDERNAME_MAX];          //目录名
struct FOLDERS* nextFolder;       //同级下一目录
struct FOLDERS* frontFolder;       //同级上一目录
struct FOLDERS* parentFolder;       //父目录
struct FOLDERS* firstChildFolder; //子目录
struct FILES* firstChildFile;       //首个子文件
struct FILES* lastChildFile;    //最后一个子文件
int canRead;          //是否可读
int canWrite;          //是否可写
}FOLDERS;

int login();//登录函数
struct USER QueryUser(account,pwd);//用户表
void getPath(FOLDERS* nowPath);//获取当前文件夹路径
void getAllFolder(FOLDERS* nowFOLDER, int userRights);//显示当前目录下所有文件夹
void getAllFile(FOLDERS* nowFOLDER, int useRights);//进入文件
void modifyFolder(FOLDERS* handFFOLDER, int userRights);//修改目录
void modifyFile(FILES *handFFILE,int userRights);//修改文件
void backParFolder(FOLDERS *nowFOLDER);//返回父目录
void OperateFolder(FOLDERS* nowFOLDER, int userRights);//操作当前目录下文件夹
void OperateFile(FOLDERS *nowFOLDER,int userRights);//操作当前文件
void CreatRootFolder(FOLDERS* rootFolder);//创建根目录

int main()
{

FOLDERS* LF, * nowFolder,*parFolder;
LF = (FOLDERS*)malloc(sizeof(FOLDERS));
nowFolder = (FOLDERS*)malloc(sizeof(FOLDERS));
parFolder = (FOLDERS*)malloc(sizeof(FOLDERS));
parFolder=NULL;
CreatRootFolder(LF);//创建根目录
nowFolder = LF;

int Choice = 0;
int userRights = 0;
userRights = login();

while (1)
{
printf("------------------------------------\n\n");
getPath(nowFolder);
printf("1.查看当前目录下内容\n");
printf("2.返回父目录\n");
printf("3.在当前目录下操作文件夹\n");
printf("4.在当前目录下操作文件\n");
printf("5.退出系统\n");
printf("请输入要进行的操作序号:");
scanf("%d", &Choice);

switch (Choice) {
case 1:
getAllFolder(nowFolder, userRights);
getAllFile(nowFolder, userRights);
break;
case 2:
         backParFolder(nowFolder);
break;
case 3:
OperateFolder(nowFolder, userRights);
break;
case 4:
OperateFile(nowFolder, userRights);
break;
case 5:
userRights = login();
break;

}
Choice = 0;

}

}
int login()
{
char account[256];
char pwd[256];
printf("----------登录文件查询系统----------\n");
printf("账号:");
scanf("%s", account);
printf("密码:");
scanf("%s", pwd);
printf("------------------------------------\n");
USER  user = QueryUser(&account, &pwd);

if(user.state==0)
{
      printf("登录失败!\n");
      login();
}
else
{
      printf("用户权限:%d\n", user.userRights);
      return user.userRights;
}

}
struct USER QueryUser(char account[256], char pwd[256])//查询用户信息
{
struct USER userlist[10] = {

   {"admin",0,"admin","admin",0},
   {"user1",1,"user1","123456",0},
   {"user2",2,"user2","123456",0},
   {"user3",3,"user3","123456",0},
   {"user4",2,"user4","12345678",0}

};

struct  USER FailUser = { "登陆失败",3,"登陆失败","登陆失败",0 };

for (int i = 0; i < 5; i++)
{
if (strcmp(account, userlist[i].account) == 0)
{
if (strcmp(pwd, userlist[i].password) == 0)
{
userlist[i].state = 1;
printf("登陆成功!欢迎你%s!\n", userlist[i].name);
return userlist[i];
}
else printf("密码错误!\n");

return FailUser;

}
}

printf("账号不存在!\n");
return FailUser;

}

void getPath(FOLDERS *nowFOLDER)
{
FOLDERS* handFOLDER;
handFOLDER = (FOLDERS*)malloc(sizeof(FOLDERS));
handFOLDER = nowFOLDER;
char nowPath[1000], tempPath[1000]="/", a[1000]="";
strcpy(nowPath, strcat(tempPath, handFOLDER->name));

while (1)
{
      memset(a,'\0',sizeof(a));
      a[0]='/';
if (handFOLDER->parentFolder != NULL)
{
handFOLDER = handFOLDER->parentFolder;
         strcat(a,handFOLDER->name);
         strcat(a,nowPath );
strcpy(nowPath,a);

}

else
{
printf("当前位置:%s\n", nowPath);
break;
}
}

}

void CreatRootFolder(FOLDERS* rootFolder) {
FOLDERS* r = rootFolder;
strcpy(r->name, "root");
r->nextFolder = NULL;
r->frontFolder = NULL;
r->firstChildFolder = NULL;
r->firstChildFile = NULL;
r->parentFolder = NULL;
r->lastChildFile = NULL;
r->canRead = 3;
r->canWrite = 0;
printf("创建根目录%s成功!\n", r->name);
}

void getAllFolder(FOLDERS* nowFOLDER, int userRights) {

if(nowFOLDER->canRead < userRights)
{
printf("权限不足无法读取该目录！\n");
return 0;
}
else
{
FOLDERS* handFOLDER;//当前遍历到的目录
handFOLDER = (FOLDERS*)malloc(sizeof(FOLDERS));
handFOLDER = nowFOLDER;

if (handFOLDER->firstChildFolder == NULL)
{
printf("当前目录下无子目录\n");
}
else
{

printf("当前目录下的子目录列表：\n");
handFOLDER = handFOLDER->firstChildFolder;
printf("/%s\n", handFOLDER->name);

while (1)
{
handFOLDER = handFOLDER->nextFolder;
if (handFOLDER->name == NULL)
{
break;
}
else
{

printf("/%s\n", handFOLDER->name);

}

}

}

}

}

void modifyFolder(FOLDERS *modifyFOLDER, int userRights)
{

printf("当前目录信息:\n");
printf("目录名:%s\n", modifyFOLDER->name);
printf("可读权限:%d\n", modifyFOLDER->canRead);
printf("可写权限:%d\n", modifyFOLDER->canWrite);

while (1)
{
int Choice = 0;
printf("------------------------------------\n\n");
printf("1.文件名\n");
printf("2.可读权限\n");
printf("3.可写权限\n");
printf("4.退出修改\n");
printf("请输入要修改的选项:");
scanf("%d", &Choice);

if (Choice == 1)
{
int flag = 0;
char name[256];
FOLDERS* handFOLDER;
handFOLDER = (FOLDERS*)malloc(sizeof(FOLDERS));
handFOLDER = modifyFOLDER;
printf("请输入新的目录名:");
scanf("%s,", name);
while (1)
{
if (handFOLDER->frontFolder != NULL)
{
handFOLDER = handFOLDER->frontFolder;
if (strcmp(handFOLDER->name, name) && strlen(handFOLDER->name) == strlen(name))
{
printf("该目录名已存在!\n");
flag = 1;
break;
}
}
else
flag = 0;
break;
}
while (1)
{
if (handFOLDER->nextFolder != NULL && flag == 0)
{
handFOLDER = handFOLDER->nextFolder;
if (strcmp(handFOLDER->name, name) && strlen(handFOLDER->name) == strlen(name))
{
printf("该目录名已存在!\n");
flag = 1;
break;
}
}
else
flag = 0;
break;
}

if (flag == 0)
{
strcpy(modifyFOLDER->name, name);
printf("修改目录名成功!\n");
}

}

if (Choice == 2)
{
int read = 3;
printf("请输入可读权限:");
scanf("%d", &read);
if (read < userRights)
printf("无法修改为更高权限!\n");
else if (read > 3)
printf("无法修改为低于3的权限!\n");
else
{
modifyFOLDER->canRead = NULL;
modifyFOLDER->canRead = read;
printf("修改可读权限成功!\n");
}
}

if (Choice == 3)
{
int write = 3;
printf("请输入可写权限:");
scanf("%d", &write);
if (write < userRights)
printf("无法修改为更高权限!\n");
else if (write > 3)
printf("无法修改为低于3的权限!\n");
else
{
modifyFOLDER->canWrite = NULL;
modifyFOLDER->canWrite = write;
printf("修改可写权限成功!\n");
}
}
if (Choice == 4)
break;

}

}

void modifyFile(FILES *modifyFILE,int userRights){
if(userRights>modifyFILE->canWrite)
      {
         printf("用户权限不足无法修改该文件!\n");
         return 0;
      }
else
      {
         while(1)
         {
            int Choice=0;
            printf("1.文件名\n");
            printf("2.可读权限\n");
            printf("3.可写权限\n");
            printf("4.修改文件内容\n");
            printf("5.退出修改\n");
            printf("请输入要修改项:");
            scanf("%d",&Choice);
            FILES *handFILE;
            handFILE = (FILES*)malloc(sizeof(FILES));
            handFILE = modifyFILE;

            if(Choice==1)
            {
                  int flag=0;
                  char name[256]="";
                  printf("请输入文件名:");
                  scanf("%s",name);
                  while(1)
                  {
                     if(handFILE->frontFile!=NULL&&flag==0)
                     {
                        handFILE=handFILE->frontFile;
                        if(strcmp(handFILE->name,name) == 0 && strlen(handFILE->name) == strlen(name))
                        flag=1;
                     }
                     else if(flag==1)
                     {
                        printf("1该目录下已存在该文件!\n");
                        break;
                     }
                     else if(handFILE->frontFile==NULL&&flag==0)
                        break;

                  }
                  if(flag==0)
                  {
                     while(1)
                        {
                              if(handFILE->nextFile!=NULL&&flag==0)
                              {
                                 handFILE=handFILE->nextFile;
                                 if(strcmp(handFILE->name,name) == 0 && strlen(handFILE->name) == strlen(name))
                                 flag=1;
                              }
                                 else if(flag==1)
                                 {
                                    printf("2该目录下已存在该文件!\n");
                                    break;
                                 }
                                 else if(handFILE->nextFile==NULL&&flag==0)
                                    break;

                        }
                  }
                  if(flag==0)
                  {
                     strcpy(modifyFILE->name,name);
                     printf("修改文件名成功!\n");
                  }

            }

            if(Choice==2)
                  {
                     int read=0;
                     printf("请输入可读权限:");
                     scanf("%d",&read);
                     if(read<userRights)
                        printf("修改的权限大于了用户权限，修改失败!\n");
                     else if(read>3)
                        printf("修改的权限不可大于3，修改失败!\n");
                     else
                        {
                              modifyFILE->canRead=read;
                              printf("修改成功!\n");
                        }

                  }

            if(Choice==3)
                  {
                     int write=0;
                     printf("请输入可读权限:");
                     scanf("%d",&write);
                     if(write<userRights)
                        printf("修改的权限大于了用户权限，修改失败!\n");
                     else if(write>3)
                        printf("修改的权限不可大于3，修改失败!\n");
                     else
                        {
                              modifyFILE->canWrite=write;
                              printf("修改成功!\n");
                        }

                  }

            if(Choice==4)
            {
                  strcpy(modifyFILE->content,"");
                  printf("请输入文件内容以 #! 作为结束符:\n");
                  int fileslen = 0;
                  char ch;
                  while ((ch = getchar()))
                  {
                     if (ch == '!' && modifyFILE->content[fileslen - 1] == '#')
                     {
                        modifyFILE->content[fileslen] = ch;
                        break;
                     }
                     else
                     {
                        modifyFILE->content[fileslen] = ch;
                        fileslen++;
                     }
                  }
                  printf("修改文件内容成功!\n");
            }

            if(Choice==5)
                  return 0;

         }

      }

}
void backParFolder(FOLDERS *nowFOLDER){
if(nowFOLDER->parentFolder!=NULL)
{
      FOLDERS *parFOLDER;
      parFOLDER = (FOLDERS*)malloc(sizeof(FOLDERS));
      parFOLDER = nowFOLDER->parentFolder;
      *nowFOLDER = *parFOLDER;
}
else
      printf("无父目录!\n");
return 0;
}

void OperateFolder(FOLDERS* nowFOLDER, int userRights) {
int Choice;
printf("------------------------------------\n\n");
printf("1.进入子目录\n");
printf("2.创建子目录\n");
printf("3.删除子目录\n");
printf("4.修改子目录\n");
printf("5.返回目录操作项\n");
printf("请选择要操作的序列号:");
scanf("%d", &Choice);
printf("------------------------------------\n\n");

if (Choice == 1)
{
char name[100];
printf("请输入要进入的子目录:");
scanf("%s", name);
FOLDERS* handFFOLDER;
handFFOLDER = (FOLDERS*)malloc(sizeof(FOLDERS));
handFFOLDER = nowFOLDER;

if (handFFOLDER->firstChildFolder != NULL)
{
handFFOLDER = handFFOLDER->firstChildFolder;

if (strcmp(handFFOLDER->name, name) == 0 && strlen(name) == strlen(handFFOLDER->name))
{
      if(userRights<handFFOLDER->canRead)
            {
                  printf("handFFOLDER:%s\n", handFFOLDER->name);
                  printf("handFFOLDERparent:%s\n", handFFOLDER->parentFolder);
                  printf("nowfolder:%s\n",nowFOLDER->name);
                  FOLDERS *parFOLDER;
                  parFOLDER=(FOLDERS *)malloc(sizeof (FOLDERS));
                  strcpy(parFOLDER->name,nowFOLDER->name);
                  parFOLDER->canRead=nowFOLDER->canRead;
                  parFOLDER->canWrite=nowFOLDER->canWrite;
                  parFOLDER->firstChildFile=nowFOLDER->firstChildFile;
                  parFOLDER->firstChildFolder=nowFOLDER->firstChildFolder;
                  parFOLDER->nextFolder=nowFOLDER->nextFolder;
                  parFOLDER->parentFolder=nowFOLDER->parentFolder;
                  parFOLDER->frontFolder=nowFOLDER->frontFolder;
                  parFOLDER->lastChildFile=parFOLDER->lastChildFile;
                  *nowFOLDER=*handFFOLDER ;
                  nowFOLDER->parentFolder=parFOLDER;
                  return 0;
            }
            else
            {
                  printf("用户权限不足无法进入!\n");
                  return 0;
            }

}

else
{
if (handFFOLDER->nextFolder != NULL)
{
handFFOLDER = handFFOLDER->nextFolder;
while (1)
{
if (handFFOLDER != NULL)
{
if (strcmp(handFFOLDER->name, name) == 0 && strlen(name) == strlen(handFFOLDER->name))
{
                              if(userRights<handFFOLDER->canRead)
                              {
                                 FOLDERS *parFOLDER;
                                 parFOLDER=(FOLDERS *)malloc(sizeof (FOLDERS));
                                 strcpy(parFOLDER->name,nowFOLDER->name);
                                 parFOLDER->canRead=nowFOLDER->canRead;
                                 parFOLDER->canWrite=nowFOLDER->canWrite;
                                 parFOLDER->firstChildFile=nowFOLDER->firstChildFile;
                                 parFOLDER->firstChildFolder=nowFOLDER->firstChildFolder;
                                 parFOLDER->nextFolder=nowFOLDER->nextFolder;
                                 parFOLDER->parentFolder=nowFOLDER->parentFolder;
                                 parFOLDER->frontFolder=nowFOLDER->frontFolder;
                                 parFOLDER->lastChildFile=parFOLDER->lastChildFile;
                                 *nowFOLDER=*handFFOLDER;
                                 nowFOLDER->parentFolder=parFOLDER;
                                 return 0;
                              }
                              else
                              {
                                 printf("用户权限不足无法进入!\n");
                                 return 0;
                              }

}
else
{
handFFOLDER = handFFOLDER->nextFolder;
}

}
else
break;
}

}

}
printf("该文件夹不存在！\n");
return 0;

}

else
{
printf("当前目录下文件夹为空!\n");
return 0;
}

getAllFolder(handFFOLDER, userRights);

}

else if (Choice == 2)
{

FOLDERS* newFOLDER, * handFOLDER;//新的文件夹,目前文件夹
newFOLDER = (FOLDERS*)malloc(sizeof(FOLDERS));
handFOLDER = (FOLDERS*)malloc(sizeof(FOLDERS));
handFOLDER = nowFOLDER;

char name[100];
printf("请输入要创建目录的名称：");
scanf("%s", newFOLDER->name);

newFOLDER->nextFolder = NULL;
newFOLDER->firstChildFile = NULL;
newFOLDER->firstChildFolder = NULL;
newFOLDER->parentFolder = handFOLDER;
newFOLDER->canRead = userRights;
newFOLDER->canWrite = userRights;
newFOLDER->lastChildFile = NULL;

if (handFOLDER->firstChildFolder == NULL)
{

handFOLDER->firstChildFolder = newFOLDER;

}

else
{
handFOLDER = handFOLDER->firstChildFolder;
while (1)
{
if (strcmp(handFOLDER->name, newFOLDER->name) == 0 && strlen(handFOLDER->name) == strlen(newFOLDER->name))
{
printf("该目录已存在,请修改名称后创建!\n");
return 0;
}
if (handFOLDER->nextFolder != NULL)
handFOLDER = handFOLDER->nextFolder;
else
{
handFOLDER->nextFolder = newFOLDER;
newFOLDER->frontFolder = handFOLDER;
break;
}

}
}

printf("创建新文件夹成功！\n");
getAllFolder(nowFOLDER, userRights);
return 0;

}

if (Choice == 3)
{

char name[100];
printf("请输入要删除的子目录:");
scanf("%s", name);
FOLDERS* handFFOLDER, * handnext;
handFFOLDER = (FOLDERS*)malloc(sizeof(FOLDERS));
handnext = (FOLDERS*)malloc(sizeof(FOLDERS));
handFFOLDER = nowFOLDER;
if (handFFOLDER->firstChildFolder != NULL)
{
handFFOLDER = handFFOLDER->firstChildFolder;
if (strcmp(handFFOLDER->name, name) == 0 && strlen(handFFOLDER->name) == strlen(name))
{
      if(userRights>handFFOLDER->canWrite)
                  {
                     printf("权限不足无法删除!\n");
                     return 0;
                  }
            else
            {
               if (handFFOLDER->nextFolder == NULL)
                     nowFOLDER->firstChildFolder = NULL;
                  else
                  {
                     handFFOLDER = handFFOLDER->nextFolder;
                     nowFOLDER->firstChildFolder = handFFOLDER;
                     handFFOLDER->frontFolder = NULL;
                  }
printf("删除目录成功!\n");
return 0;
            }

}

else
{
while (1)
{
handFFOLDER = handFFOLDER->nextFolder;
if (strcmp(handFFOLDER->name, name) == 0 && strlen(handFFOLDER->name) == strlen(name))
{
if (handFFOLDER->nextFolder == NULL)
{
      if(userRights>handFFOLDER->canWrite)
                              {
                                 printf("权限不足无法删除!\n");
                                 return 0;
                              }
                              else
                              {
                              handFFOLDER = handFFOLDER->frontFolder;
                                 handFFOLDER->nextFolder = NULL;
                                 printf("删除目录成功!\n");
                                 return 0;
                              }

}

else
{
      if(userRights>handFFOLDER->canWrite)
                              {
                                 printf("权限不足无法删除!\n");
                                 return 0;
                              }
                              else
                              {
                                 handnext = handFFOLDER->nextFolder;
                                 handFFOLDER = handFFOLDER->frontFolder;
                                 handFFOLDER->nextFolder = handnext;
                                 handnext->frontFolder = handFFOLDER;
                                 printf("删除目录成功!\n");
                                 return 0;
                              }

}

}

if (handFFOLDER->nextFolder == NULL)
{
printf("该目录不存在!\n");
return 0;
}
}

}
}
printf("该目录下无子目录!\n");
return 0;

}

if (Choice == 4)
{
char name[100];
printf("请输入要修改的子目录:");
scanf("%s", name);
FOLDERS* handFFOLDER;
handFFOLDER = (FOLDERS*)malloc(sizeof(FOLDERS));
handFFOLDER = nowFOLDER;
if (handFFOLDER->firstChildFolder != NULL)
{
handFFOLDER = handFFOLDER->firstChildFolder;
if (strcmp(handFFOLDER->name, name) == 0 && strlen(handFFOLDER->name) == strlen(name))
{
printf("userr:%d\n", userRights);
if (handFFOLDER->canWrite < userRights)
printf("用户权限不足无法修改!\n");
else
modifyFolder(handFFOLDER, userRights);
return 0;
}

else
{
while (1)
{
if (handFFOLDER->nextFolder != NULL)
{
      handFFOLDER = handFFOLDER->nextFolder;
      if (strcmp(handFFOLDER->name,name) == 0 && strlen(handFFOLDER->name) == strlen(name))
{
if (handFFOLDER->canWrite < userRights)
printf("用户权限不足无法修改!\n");
else
                           {
modifyFolder(handFFOLDER, userRights);
                           }
return 0;
}

}
else
{

                     printf("该目录不存在!\n");
return 0;

}
}

}
}
else
{
printf("该目录不存在!\n");
return 0;
}

}

}

void getAllFile(FOLDERS* nowFOLDER, int useRights) {

if (nowFOLDER->firstChildFile != NULL)
{
printf("当前目录下子文件列表:\n");
FILES* handFile;
handFile = (FILES*)malloc(sizeof(FILES));
handFile = nowFOLDER->firstChildFile;
printf("%s\n", handFile->name);
while (1)
{
if (handFile->nextFile == NULL)
break;
else
{
handFile = handFile->nextFile;
printf("%s\n", handFile->name);
}

}

}

else
printf("该目录下无文件!\n");
}

void OperateFile(FOLDERS* nowFolder, int userRights) {
int Choice;
printf("------------------------------------\n\n");
printf("1.查看子文件\n");
printf("2.创建子文件\n");
printf("3.删除子文件\n");
printf("4.修改子文件\n");
printf("5.返回目录操作项\n");
printf("请选择要操作的序列号:");
scanf("%d", &Choice);
printf("------------------------------------\n\n");
if (Choice == 1)
{

if (nowFolder->firstChildFile != NULL)
{
char name[256];
printf("请输入要查看的文件名:");
scanf("%s", name);
FILES* handFFile;
handFFile = (FILES*)malloc(sizeof(FILES));
handFFile = nowFolder->firstChildFile;
while (1)
{
if (strcmp(handFFile, name) == 0 && strlen(handFFile->name) == strlen(name))
{
if (handFFile->canRead < userRights)
{
printf("用户权限不足无法读取该文件!\n");
return 0;
}

else
{
printf("文件可读权限:%d\n", handFFile->canRead);
printf("文件可写权限:%d\n", handFFile->canWrite);
printf("文件内容:\n");
int clen = 0;
while (1)
{
if (handFFile->content[clen] == '#' && handFFile->content[clen + 1] == '!')
break;
else
{
printf("%c", handFFile->content[clen]);
clen++;
}
}
printf("\n");

return 0;
}

}

else
{
if (handFFile->nextFile != NULL)
handFFile = handFFile->nextFile;
else
                     {
                     printf("该目录不存在该文件!\n");
break;
                     }
}

}
}
else
printf("该目录下无文件夹!\n");
}
else if (Choice == 2)
{
FILES* newFile, * handFile;
handFile = (FILES*)malloc(sizeof(FILES));
newFile = (FILES*)malloc(sizeof(FILES));
newFile->parentFolder = nowFolder;
newFile->nextFile = NULL;
newFile->frontFile = NULL;
newFile->canRead = userRights;
newFile->canWrite = userRights;

printf("请输入文件名:");
scanf("%s", newFile->name);

if (nowFolder->firstChildFile == NULL)
{
nowFolder->firstChildFile = newFile;
nowFolder->lastChildFile = newFile;
}
else
{
handFile = nowFolder->firstChildFile;
while (1)
{
if (strcmp(handFile->name, newFile->name) == 0 && strlen(handFile->name) == strlen(newFile->name))
{
printf("该文件已存在，请更改文件名!\n");
return 0;
}
if (handFile->nextFile == NULL)
{
handFile->nextFile = newFile;
newFile->frontFile = handFile;
nowFolder->lastChildFile = newFile;
break;
}
else
handFile = handFile->nextFile;
}
}

printf("请输入文件内容以 #! 作为结束符:\n");
int fileslen = 0;
char ch;
while ((ch = getchar()))
{
if (ch == '!' && newFile->content[fileslen - 1] == '#')
{
newFile->content[fileslen] = ch;
break;
}
else
{
newFile->content[fileslen] = ch;
fileslen++;
}
}
printf("创建新文件%s成功！\n", newFile->name);
return 0;
}
else if (Choice == 3)
{
      if(nowFolder->firstChildFile!=NULL)
      {
         FILES *handFFILE;
         handFFILE = (FILES*)malloc(sizeof(FILES));
         handFFILE=nowFolder->firstChildFile;

         char name[256];
         printf("请输入要删除的文件名:");
         scanf("%s",name);
         if(strcmp(handFFILE->name,name)==0&&strlen(handFFILE->name)==strlen(name))
            {
                  if(userRights>handFFILE->canWrite)
                     {
                        printf("权限不足无法删除!\n");
                        return 0;
                     }
                  else
                     {
                        if(handFFILE->nextFile==NULL)
                        {
                              nowFolder->firstChildFile=NULL;
                              handFFILE->parentFolder=NULL;
                        }
                        else
                              {
                              handFFILE->parentFolder=NULL;
                              handFFILE=handFFILE->nextFile;
                              nowFolder->firstChildFile=handFFILE;
                              handFFILE->frontFile=NULL;

                        }
                        printf("删除文件成功!\n");
                        return 0;
                     }

            }
         if(handFFILE->nextFile!=NULL)
         {
            while(1)
            {
                  handFFILE=handFFILE->nextFile;
                  if(strcmp(handFFILE->name,name)==0&&strlen(handFFILE->name)==strlen(name))
                  {
                     if(userRights>handFFILE->canWrite)
                     {
                        printf("权限不足无法删除!\n");
                        return 0;
                     }
                     else
                     {
                        if(handFFILE->nextFile==NULL)
                        {
                              handFFILE=handFFILE->frontFile;
                              handFFILE->nextFile=NULL;
                        }
                        else
                        {
                              FILES *handnext;
                              handnext = (FILES*)malloc(sizeof(FILES));
                              handnext=handFFILE->nextFile;
                              handFFILE=handFFILE->frontFile;
                              handFFILE->nextFile=handnext;
                              handnext->frontFile=handFFILE;

                        }
                        printf("删除文件成功!\n");
                        return 0;
                     }

                  }
                  if(handFFILE->nextFile==NULL)
                  {
                     printf("该文件不存在!\n");
                     return 0;
                  }

            }
         }

      }
      else
         printf("该目录下不存在文件!\n");
         return 0;

}

else if (Choice == 4)
      {
      if(nowFolder->firstChildFile!=NULL)
      {
         FILES *handFFILE;
         handFFILE = (FILES*)malloc(sizeof(FILES));
         handFFILE=nowFolder->firstChildFile;

         char name[256];
         printf("请输入要修改的文件名:");
         scanf("%s",name);
         if(strcmp(handFFILE->name,name)==0&&strlen(handFFILE->name)==strlen(name))
            {
                  modifyFile(handFFILE,userRights);
                  return 0;
            }
         if(handFFILE->nextFile!=NULL)
         {
            while(1)
            {
                  handFFILE=handFFILE->nextFile;
                  if(strcmp(handFFILE->name,name)==0&&strlen(handFFILE->name)==strlen(name))
                     {
                        modifyFile(handFFILE,userRights);
                        return 0;
                     }
                  if(handFFILE->nextFile==NULL)
                  {
                     printf("该文件不存在!\n");
                     return 0;
                  }

            }
         }

      }
      else
         printf("该目录下不存在文件!\n");
         return 0;
}
else if (Choice == 5)
      return 0;
}

FishC · 发表于前天 14:19

赵屿发表于 2024-12-19 14:02
详细补充以下代码要求满足以下条件
（1）设置和修改 ...

你已经提供了一大段代码，我将帮助解决一些常见问题并确保满足指定的需求。为简洁起见，我只会给出补充的关键代码段或修正建议：

1. **用户权限设置和修改：**

你已有的`USER`结构体中包括了`userRights`字段，但缺少实际检查和修改权限的功能。在`modifyFile`和`modifyFolder`等函数中已经考虑了权限检查。如需修改权限，可以在适当的函数中添加用户输入来修改可读(`canRead`)和可写(`canWrite`)权限。

2. **创建、改变和删除目录的服务：**

你已有的`OperateFolder`函数涵盖了创建、进入和删除目录的功能，改进代码结构时请确保逻辑清晰，添加目录创建的路径输入，创建失败的处理等。

3. **共享文件和设定访问路径：**

当前设计为单用户体验，文件和不同用户间的共享机制未实现。你可以通过增设一个共享标志或在文件中添加共享用户列表来改进。

4. **文件操作（创建、读写、删除）：**

主要在`OperateFile`函数实现。可以改进以下几点：

- 在文件内容读取的位置使用`fgetc`改为逐字符读取。
- 确保字串处理正确，避免越界问题。

void readFileContents(FILES *file) {
    if (!file) return;
    char ch;
    FILE *fp = fopen(file->name, "r");
    if (!fp) {
        perror("文件打开失败");
        return;
    }
    while ((ch = fgetc(fp)) != EOF) {
        putchar(ch);
    }
    fclose(fp);
    printf("\n文件读取完毕!\n");
}

// 使用示例
void showFileContentIfAllowed(FILES* file, int userRights) {
    if (file->canRead <= userRights) {
        readFileContents(file);
    } else {
        printf("权限不足无法读取该文件！\n");
    }
}

5. **错误修复：**

- 代码段中许多字符串和变量初始化出现语法错误，如：`char name;`应该定义为数组，如`char name[256];`
- 不同库函数的使用，如`strcpy`和比较应采用`strcmp`，确保包括`<string.h>`

6. **修改和清理：**

- 变量初始化，确保变量使用前正确初始化。
- 确保内存分配和释放，使用`malloc`后须检查指针。

因字符限制无法全部列出修改后的完整代码，如有具体的问题，请详细指出相关的代码段或功能需求！建议逐步调试和完善每个模块。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

赵屿 · 发表于前天 15:07

FishC 发表于 2024-12-19 14:19
你已经提供了一大段代码，我将帮助解决一些常见问题并确保满足指定的需求。为简洁起见，我只会给出补充 ...

修改权限，怎么在适当的函数中添加用户输入来修改可读(`canRead`)和可写(`canWrite`)权限，请写详细代码

FishC · 发表于前天 15:09

赵屿发表于 2024-12-19 15:07
修改权限，怎么在适当的函数中添加用户输入来修改可读 ...

要在函数中实现修改文件或目录的权限，我们需要提供用户输入接口并检查权限的合法性。假设我们在`modifyFolder`和`modifyFile`函数中增加这个功能，代码修改如下：

### 修改文件夹权限的代码示例：

void modifyFolder(FOLDERS *modifyFOLDER, int userRights) {
    printf("当前目录信息:\n");
    printf("目录名: %s\n", modifyFOLDER->name);
    printf("可读权限: %d\n", modifyFOLDER->canRead);
    printf("可写权限: %d\n", modifyFOLDER->canWrite);

    while (1) {
        int Choice = 0;
        printf("------------------------------------\n");
        printf("1.修改目录名\n");
        printf("2.修改可读权限\n");
        printf("3.修改可写权限\n");
        printf("4.退出修改\n");
        printf("请输入要修改的选项: ");
        scanf("%d", &Choice);

        if (Choice == 1) {
            char newName[FOLDERNAME_MAX];
            printf("请输入新的目录名: ");
            scanf("%s", newName);
            // 假设这里需要检查名字是否已存在，省略详细检查逻辑
            strcpy(modifyFOLDER->name, newName);
            printf("修改目录名成功!\n");
        } else if (Choice == 2) {
            int newRead;
            printf("请输入新的可读权限 (0-3): ");
            scanf("%d", &newRead);
            if (newRead <= userRights) {
                modifyFOLDER->canRead = newRead;
                printf("修改可读权限成功!\n");
            } else {
                printf("无权限设置超过当前用户权限!\n");
            }
        } else if (Choice == 3) {
            int newWrite;
            printf("请输入新的可写权限 (0-3): ");
            scanf("%d", &newWrite);
            if (newWrite <= userRights) {
                modifyFOLDER->canWrite = newWrite;
                printf("修改可写权限成功!\n");
            } else {
                printf("无权限设置超过当前用户权限!\n");
            }
        } else if (Choice == 4) {
            break;
        } else {
            printf("无效选项，请重新选择。\n");
        }
    }
}

### 修改文件权限的代码示例：

void modifyFile(FILES *modifyFILE, int userRights) {
    if (userRights > modifyFILE->canWrite) {
        printf("用户权限不足，无法修改该文件!\n");
        return;
    } else {
        while (1) {
            int Choice = 0;
            printf("文件名: %s\n", modifyFILE->name);
            printf("1. 修改文件名\n");
            printf("2. 修改可读权限\n");
            printf("3. 修改可写权限\n");
            printf("4. 修改文件内容\n");
            printf("5. 退出修改\n");
            printf("请输入要修改的选项: ");
            scanf("%d", &Choice);

            if (Choice == 1) {
                char newName[FILENAME_MAX];
                printf("请输入新的文件名: ");
                scanf("%s", newName);
                // 假设这里需要检查名字是否已存在，省略详细检查逻辑
                strcpy(modifyFILE->name, newName);
                printf("修改文件名成功!\n");
            } else if (Choice == 2) {
                int newRead;
                printf("请输入新的可读权限 (0-3): ");
                scanf("%d", &newRead);
                if (newRead <= userRights) {
                    modifyFILE->canRead = newRead;
                    printf("修改可读权限成功!\n");
                } else {
                    printf("无权限设置超过当前用户权限!\n");
                }
            } else if (Choice == 3) {
                int newWrite;
                printf("请输入新的可写权限 (0-3): ");
                scanf("%d", &newWrite);
                if (newWrite <= userRights) {
                    modifyFILE->canWrite = newWrite;
                    printf("修改可写权限成功!\n");
                } else {
                    printf("无权限设置超过当前用户权限!\n");
                }
            } else if (Choice == 4) {
                printf("请输入新的文件内容，以 #! 作为结束符：\n");
                int fileslen = 0;
                char ch;
                while ((ch = getchar()) != EOF) {
                    if (ch == '!' && modifyFILE->content[fileslen - 1] == '#') {
                        break;
                    }
                    modifyFILE->content[fileslen++] = ch;
                }
                modifyFILE->content[fileslen] = '\0';
                printf("修改文件内容成功!\n");
            } else if (Choice == 5) {
                return;
            } else {
                printf("无效选项，请重新选择。\n");
            }
        }
    }
}

### 说明

- 在`入口选择`处，代码会根据用户输入选择修改内容。
- 权限修改选项需要验证输入权限值（0到3之间）。
- 使用`sprintf`处理字符串输入，并在各个选择加上权限的逻辑判断。
- 在实际实现中，需要确保输入交换产生的数值在合法范围内。

确保将以上修改应用在你的主代码片段中合适的位置上。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

赵屿 · 发表于前天 15:59

FishC 发表于 2024-12-19 15:09
要在函数中实现修改文件或目录的权限，我们需要提供用户输入接口并检查权限的合法性。假设我们在`modif ...

2. **创建、改变和删除目录的服务：**

你已有的`OperateFolder`函数涵盖了创建、进入和删除目录的功能，请给出这部分详细代码注释

FishC · 发表于前天 16:02

赵屿发表于 2024-12-19 15:59
2. **创建、改变和删除目录的服务：**

你已有的 ...

下面是`OperateFolder`函数的详细注释代码示例，涵盖了如何创建、进入和删除目录的功能：

void OperateFolder(FOLDERS* nowFOLDER, int userRights) {
    int Choice;
    printf("------------------------------------\n\n");
    printf("1.进入子目录\n");
    printf("2.创建子目录\n");
    printf("3.删除子目录\n");
    printf("4.修改子目录\n");
    printf("5.返回目录操作项\n");
    printf("请选择要操作的序列号: ");
    scanf("%d", &Choice);
    printf("------------------------------------\n\n");

    if (Choice == 1) {
        // 进入子目录
        char name[FOLDERNAME_MAX];
        printf("请输入要进入的子目录名: ");
        scanf("%s", name);
        FOLDERS* handFFOLDER = nowFOLDER->firstChildFolder;

        // 遍历当前目录的子目录列表
        while (handFFOLDER != NULL) {
            if (strcmp(handFFOLDER->name, name) == 0) { // 匹配子目录名
                if (userRights <= handFFOLDER->canRead) { // 检查权限
                    *nowFOLDER = *handFFOLDER; // 更新当前目录为子目录
                    printf("成功进入目录: %s\n", nowFOLDER->name);
                    return;
                } else {
                    printf("权限不足，无法进入该目录!\n");
                    return;
                }
            }
            handFFOLDER = handFFOLDER->nextFolder;
        }
        printf("该子目录不存在!\n");

    } else if (Choice == 2) {
        // 创建新子目录
        if (userRights > nowFOLDER->canWrite) {
            printf("权限不足，无法创建子目录!\n");
            return;
        }

        FOLDERS* newFOLDER = (FOLDERS*)malloc(sizeof(FOLDERS));
        printf("请输入要创建的目录名: ");
        scanf("%s", newFOLDER->name);
        newFOLDER->firstChildFolder = NULL;
        newFOLDER->firstChildFile = NULL;
        newFOLDER->parentFolder = nowFOLDER;
        newFOLDER->canRead = userRights;
        newFOLDER->canWrite = userRights;

        // 插入新目录到当前目录的子目录列表
        if (nowFOLDER->firstChildFolder == NULL) {
            nowFOLDER->firstChildFolder = newFOLDER;
            newFOLDER->frontFolder = NULL;
        } else {
            FOLDERS* lastFOLDER = nowFOLDER->firstChildFolder;
            while (lastFOLDER->nextFolder != NULL) {
                lastFOLDER = lastFOLDER->nextFolder;
            }
            lastFOLDER->nextFolder = newFOLDER;
            newFOLDER->frontFolder = lastFOLDER;
        }
        newFOLDER->nextFolder = NULL;
        printf("创建新目录成功: %s\n", newFOLDER->name);

    } else if (Choice == 3) {
        // 删除子目录
        char name[FOLDERNAME_MAX];
        printf("请输入要删除的子目录名: ");
        scanf("%s", name);
        FOLDERS* handFFOLDER = nowFOLDER->firstChildFolder;

        while (handFFOLDER != NULL) {
            if (strcmp(handFFOLDER->name, name) == 0) {
                if (userRights > handFFOLDER->canWrite) {
                    printf("权限不足，无法删除该目录!\n");
                    return;
                }

                // 从链表中移除子目录
                if (handFFOLDER->frontFolder != NULL) {
                    handFFOLDER->frontFolder->nextFolder = handFFOLDER->nextFolder;
                } else {
                    nowFOLDER->firstChildFolder = handFFOLDER->nextFolder;
                }
                if (handFFOLDER->nextFolder != NULL) {
                    handFFOLDER->nextFolder->frontFolder = handFFOLDER->frontFolder;
                }
                free(handFFOLDER);
                printf("删除目录成功!\n");
                return;
            }
            handFFOLDER = handFFOLDER->nextFolder;
        }
        printf("该目录不存在!\n");
    } else if (Choice == 4) {
        // 修改子目录功能 - 已在之前提供
    } else if (Choice == 5) {
        return;
    }
}

### 详细注释说明

- **进入子目录**：通过子目录名称匹配当前目录的子目录列表，检查用户权限。如果权限足够，则进入子目录。
- **创建新子目录**：首先检查用户的创建权限，然后创建新的目录结构，最后将其插入到当前目录的子目录链表中。
- **删除子目录**：检查删除权限，找到目标子目录，并从链表中移除并释放内存。
- **修改子目录**：此功能之前提供，可在合适位置添加逻辑验证名称和权限修改。

此代码可能需要根据上下文进行微调，以适配你的项目结构和变量声明。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

账号		自动登录	找回密码
密码			立即注册