C语言：文件系统

已于 2024-08-03 11:11:34 修改
阅读量1.1k 收藏 26
点赞数 8
分类专栏： C 文章标签： linux 运维 服务器
于 2024-06-16 17:54:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58233509/article/details/139454019
版权

一、目录和文件

在当前目录下使用touch 创建一个名为 -a的文件:
touch -a ;  // 错误，
touch -- -a//正确
touch ./-a 正确

ls -n可以看到对象的用户id，可以在/etc/passwd中查看，/etc/group可以看到组号

获取文件属性

  #include <sys/types.h>
       #include <sys/stat.h>
       #include <unistd.h>

       int stat(const char *pathname, struct stat *statbuf);
       int fstat(int fd, struct stat *statbuf);
       int lstat(const char *pathname, struct stat *statbuf);

       #include <fcntl.h>           /* Definition of AT_* constants */
       #include <sys/stat.h>

       int fstatat(int dirfd, const char *pathname, struct stat *statbuf,
                   int flags);

         struct stat {
               dev_t     st_dev;         /* ID of device containing file */ 包含这个文件的设备ID号
               ino_t     st_ino;         /* Inode number */   ls -i可以看到inode号
               mode_t    st_mode;        /* File type and mode */ 权限信息(16位)
               nlink_t   st_nlink;       /* Number of hard links */ 硬链接数
               uid_t     st_uid;         /* User ID of owner */ 用户id
               gid_t     st_gid;         /* Group ID of owner */ 组id
               dev_t     st_rdev;        /* Device ID (if special file) */ 设备的ID号
               off_t     st_size;        /* Total size, in bytes */ 字节数
               blksize_t st_blksize;     /* Block size for filesystem I/O */ 块大小，一般512B
               blkcnt_t  st_blocks;      /* Number of 512B blocks allocated */ 占的块数

               /* Since Linux 2.6, the kernel supports nanosecond
                  precision for the following timestamp fields.
                  For the details before Linux 2.6, see NOTES. */

               struct timespec st_atim;  /* Time of last access */  上次访问时间
               struct timespec st_mtim;  /* Time of last modification */上次修改时间
               struct timespec st_ctim;  /* Time of last status change */上次改变时间

           #define st_atime st_atim.tv_sec      /* Backward compatibility */
           #define st_mtime st_mtim.tv_sec
           #define st_ctime st_ctim.tv_sec
           };

stat命令也可以查看信息

stat

将文件属性信息填入statbuf结构体，成功返回0.失败返回-1

fstat

传入文件描述符整形

lstat

传入链接文件

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

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>


static off_t flen(const char *file)
{
    struct stat st;
    if(stat(file,&st)<0 )
    {
        perror("stat()");
        exit(-1);
    }
    return st.st_size;
}

int main(int argc,char *argv[])
{
    if(argc <2)
        return -1;

    off_t len = flen(argv[1]);
    printf("%lld \n",(long long)len);

    return 0;
}

空洞文件

占用字节size大小，但是在linux下不占用磁盘空间，磁盘空间占用有：块大小*块总数。stat命令查看。

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>

int main(int argc,char *argv[] )
{
    if(argc <2)
        return -1;

    int fd;
    fd = open(argv[1],O_WRONLY|O_CREAT|O_TRUNC,0600);
    if(fd<0)
    {
        perror("open()");
        return -1;
    }
    // lseek(fd,5*1,SEEK_SET);
     lseek(fd,5LL*1024LL*1024LL*1024LL-1LL,SEEK_SET);//数字添加LL，防止计算过程中精度溢出
    write(fd,"",1);//发生一次系统调用，否则不占用空间
    close(fd);

    return 0;
}

文件访问权限

st_mode是一个16位的位图，用于表示文件的类型，文件访问权限及特殊的权限位，参考man手册：man 2  stat 

umask

使用命令：umask 可以设置 默认是 0002 
umask 0022

作用：防止产生权限过松的文件

文件权限管理

chmod

chmod命令更改文件的权限：chmod 777 temp.file 也可以使用 chmod a+x temp.file

chmod函数：int chmod(const char *pathname, mode_t mode); 

fchmod

fchmod函数：int fchmod(int fd, mode_t mode);

粘住位

粘住位又叫做T位。现在不太常用。 ll / 查看tmp目录下的文件

drwxrwxrwt  19 root root      4096 Jun  5 04:53 tmp/ （权限最后是t代表是t位）

文件系统

文件或数据的存储和管理。

FAT

FAT16/32本质是：静态存储的单链表（闭源，害怕大文件）

UFS

（开源，不怕大文件），缺陷：不善于管理小文件

面试题：给一个无符号的32位数，什么方法获取二进制有多少零，多少一？

算法-求二进制数中1的个数 - 翰墨小生 - 博客园 (cnblogs.com)

硬链接与符号连接

硬链接

ln /tmp/bigfile /tmp/bigfile_link  ln 源文件路径  目标文件路径

删除源文本不会影响硬链接文件

符号链接

ln -s /tmp/bigfile /tmp/bigfile_link  ln 源文件路径  目标文件路径

符号链接文件的size为文件名长度，块大小为0，删除源文件链接文件不可以。
函数：

        int link(const char *oldpath, const char *newpath); （链接）
        int unlink(const char *pathname);（删除，系统调用，不可移植）
        int remove(const char *pathname);（库函数-可移植）
       int rename(const char *oldpath, const char *newpath);（系统调用）

硬链接计数为0时会删除数据，否则硬链接技计数-1

硬链接与目录项是同义词，建立连接有限制：不能给分区建立，不能给目录建立。符号连接：可以跨分区，可以给目录建立。

utime

更改时间：最后一次读和写的时间。       

   struct utimbuf {
               time_t actime;       /* access time */
               time_t modtime;      /* modification time */
           };

int utime(const char *filename, const struct utimbuf *times);
 

目录的创建和销毁

mkdir       int mkdir(const char *pathname, mode_t mode);
rmdir       int rmdir(const char *pathname);

切换目录

       int chdir(const char *path);
       int fchdir(int fd);
        改变工作路径

chroot假根技术，安全机制。

       char *getcwd(char *buf, size_t size);

分析目录

glob

       #include <glob.h>

       int glob(const char *pattern, int flags,
                int (*errfunc) (const char *epath, int eerrno),
                glob_t *pglob);
       void globfree(glob_t *pglob);
 

#include <stdlib.h>
#include <stdio.h>
#include <glob.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>

#define PAT  "/etc/a*.conf"
#define PAT  "./" //不包括隐藏的文件

static int errfunc(const char*errpath,int eerrno)
{
    fprintf(stderr,"%s \n",errpath);
    fprintf(stderr,"errno = %s \n",strerror(eerrno));
    
    return 0;
}
int main(int argc,char*argv[])
{
     glob_t globres;

    int err = glob(PAT,0,errfunc,&globres);    
    if(err)
    {
        printf("err glob %d \n",err);
        exit(1);
    }
    for(int i=0;i<globres.gl_pathc;i++)
    {
        puts(globres.gl_pathv[i]);
    }
    globfree(&globres);

    return 0;
}

注意：glob第三个参数传递的是函数地址，函数中的名称一定要保持一致，否则会有警告。

opendir、closedir、readdir、rewinddir、seekdir、telldir

#include <stdlib.h>
#include <stdio.h>
#include <glob.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <dirent.h>

#define PAT "/etc"
#define PAT "./"

int main(int argc,char*argv[])
{

    DIR* dp;
    struct dirent*cur;

    dp = opendir(PAT);
    if(dp == NULL)
        exit(1);

    while(1)
    {
        cur = readdir(dp);
        if(cur ==NULL)
            break;
        puts(cur->d_name);

    }

    closedir(dp);

    return 0;
}

du命令

查看文件/目录所占空间大小，默认以K为单位。stat中一个Block大小单位为一块512B。

mydu

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <glob.h>

#define PATHSIZE 1024
static int path_noloop(const char*path)
{
    char*pos;
    pos = strrchr(path,'/');
    if(pos ==NULL)
    {
        exit(1);
    }
    if( strcmp(pos+1 ,".") ==0 || strcmp(pos+1,"..")==0   )
        return 0;
    return 1;

}
static int64_t mydu(const char*path)
{
    struct stat st;//可以加static进行优化
    char nextpath[PATHSIZE]; //可以加static进行优化
    glob_t res;
    int64_t  sum;
    
    if(lstat(path,&st)<0)//lstat解析连接文件
    {
        perror("lstat");
        exit(1);
    }
    if(!S_ISDIR(st.st_mode))
    {
    //非目录
        return st.st_blocks;
    }
    //目录
    int ret;
    strncpy(nextpath,path,PATHSIZE-1);
    strncat(nextpath,"/*",PATHSIZE-1); 
    ret = glob(nextpath,0,NULL,&res);

    strncpy(nextpath,path,PATHSIZE-1 );
    strncat(nextpath,"/.*",PATHSIZE-1);
    printf("nextpath = %s \n",nextpath);
    ret = glob(nextpath,GLOB_APPEND,NULL,&res);
    printf("glob =%d \n",ret);
    if(ret)//特殊要求指定为追加
    {
        perror("glob()");

        exit(1);
    }
    printf("res = %ld \n",res.gl_pathc);
    sum = 0;
    for(size_t i=0;i< res.gl_pathc;i++)
    {
        printf("res = %s \n",res.gl_pathv[i]);
        if(path_noloop(res.gl_pathv[i]) )
        {
            sum += mydu(res.gl_pathv[i]);
        }
    }
    sum+= st.st_blocks;
    return sum;
}

int main(int argc,char *argv[])
{
    if(argc <2)
    {
        fprintf(stderr,"Usage...\n");
        return -1;
    }
    int64_t ret;
    ret = mydu(argv[1]);

    printf("block %ld \n",ret/2);
    return 0;
}

二、系统数据文件和信息

/etc/passed

可以看到当前linux下，用户名和用户id对象关系。

        struct passwd *getpwnam(const char *name);

       struct passwd *getpwuid(uid_t uid);
      struct passwd {
               char   *pw_name;       /* username */
               char   *pw_passwd;     /* user password */
               uid_t   pw_uid;        /* user ID */
               gid_t   pw_gid;        /* group ID */
               char   *pw_gecos;      /* user information */
               char   *pw_dir;        /* home directory */
               char   *pw_shell;      /* shell program */
           };

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

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include <pwd.h>

int main(int argc,char *argv[])
{
    
    if(argc <2)
    {
        return -1;
        printf("Usage...\n");
    }
    struct passwd*pw;

    pw = getpwuid(atoi(argv[1]) );
    
    puts(pw->pw_name);
    

    return 0;
}

/etc/group

可以看到当前linux下，用户组直接的关系。

         struct group *getgrnam(const char *name);

        struct group *getgrgid(gid_t gid);


           struct group {
               char   *gr_name;        /* group name */
               char   *gr_passwd;      /* group password */
               gid_t   gr_gid;         /* group ID */
               char  **gr_mem;         /* NULL-terminated array of pointers
                                          to names of group members */
           };

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

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include <grp.h>

int main(int argc,char *argv[])
{
    
    if(argc <2)
    {
        return -1;
        printf("Usage...\n");
    }
    struct group*gr;

    gr = getgrgid(atoi(argv[1]) );
    
    puts(gr->gr_name);
    

    return 0;
}

/etc/shadow

一个很重要的文件，不可读，不可写，是属于密码的加密文件。

$1开头代表是MD5加密，    +盐（杂字串）
$2开头代表是Blowfish 加密
$5开头代表是SHA-256 加密
$6开头代表是SHA-512 加密
 


       struct spwd *getspnam(const char *name);

       struct spwd *getspent(void);

       void setspent(void);

       void endspent(void);

       struct spwd *fgetspent(FILE *stream);

       struct spwd *sgetspent(const char *s);

       int putspent(const struct spwd *p, FILE *stream);

       int lckpwdf(void);

       int ulckpwdf(void);
 

加密


     char *
     crypt(const char *phrase, const char *setting);

     char *
     crypt_r(const char *phrase, const char *setting, struct crypt_data *data);

     char *
     crypt_rn(const char *phrase, const char *setting, struct crypt_data *data, int size);

     char *
     crypt_ra(const char *phrase, const char *setting, void **data, int *size);
 

    去除回显

       char *getpass(const char *prompt);
 

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

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <shadow.h>
#include <crypt.h>
#include <string.h>

int main(int argc,char *argv[])
{
    char *pass;
    struct 	spwd* showline;
	if(argc <2)
    {
        printf("Usage...\n");
        return -1;
    }
    
    pass = getpass("PassWorld:");
	
    showline = getspnam(argv[1]);
    printf("pass = %s \n",pass ) ;


    char* cryped_pass = crypt(pass,showline->sp_pwdp); //加密
   printf("%s \n",cryped_pass);
   if( strcmp(showline->sp_pwdp,cryped_pass) ==0)
    {
        puts("OK");
    }
    else
        puts("Error");

    cryped_pass = crypt(pass,"$6$test$");
    printf("%s \n",cryped_pass);

    return 0;
}

由于 /etc/shadow 文件只能root查看，所以执行此代码需要用root用户，否则会有权限问题，会core.

时间戳

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

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <time.h>

void test(int flag)
{
    int a=10;
    time_t t = time(NULL);
    struct tm* tm;
    if(flag)
    {
        tm = localtime(&t);
    }
    printf("a = %p \n",&a);
    printf("t = %p \n",&t);
    printf("tm = %p \n",&tm);
    printf("tm = %d \n",tm->tm_year+1900);
    printf("=============================\n");

}
#define FILENAME "/tmp/out"

int main(int argc,char *argv[])
{
#if 0
	if(argc <2)
    {
        printf("Usage...\n");
        return -1;
    }
#endif

    FILE*fp=fopen(FILENAME,"a+");
    char buf[1024];
    int count;
    time_t stamp;
    struct tm* tm;
    while(1)
    {
        if( fgets(buf,sizeof(buf),fp) ==NULL)
            break;
        count++;
    }
    while(1)
    {
        time(&stamp);
        tm = localtime(&stamp);
        fprintf(fp,"%-4d%d-%d-%d %d:%d:%d\n",++count,tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,\
        tm->tm_hour,tm->tm_min,tm->tm_sec);
        fflush(fp);
        sleep(1);
    }
    fclose(fp);

    return 0;
}






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

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <time.h>

#define FILENAME "/tmp/out"

int main(int argc,char *argv[])
{
#if 0
	if(argc <2)
    {
        printf("Usage...\n");
        return -1;
    }
#endif

    time_t stamp = time(NULL);
    struct tm*tm = localtime(&stamp);
    char timestr[1024];
    strftime(timestr,1024,"Now:%Y-%m-%d ",tm);
    puts(timestr);

    tm->tm_mday +=100;

    strftime(timestr,1024,"test:%Y-%m-%d ",tm);
    puts(timestr);

    mktime(tm); //会自动进位
    
    strftime(timestr,1024,"100day:%Y-%m-%d ",tm);
    puts(timestr);
    

    return 0;
}

三、进程环境

进程的终止

正常终止

从main函数返回

调用exit

调用_exit或_Exit

最后一个线程从启动例程返回

最有一个线程调用了pthread_exit

异常终止

调用abort

接到一个信号并终止

最后一个进行对其取消请求做出响应

钩子函数atexit

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

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

void f1()
{
    puts("f1() is working ");
}

void f2()
{
    puts("f2() is working ");
}

void f3()
{
    puts("f3() is working ");
}

int main(int argc,char *argv[])
{
    puts("Begin");

    atexit(f1);
    atexit(f2);
    atexit(f3);
    puts("end");
    return 0;
}

命令行参数的分析

      给定了命令参数的数量 (argc)、指向这些参数的数组 (argv) 和选项字符串 (optstring) 后，getopt() 将返回第一个选项，并设置一些全局变量。使用相同的参数再次调用该函数时，它将返回下一个选项，并设置相应的全局变量。如果不再有识别到的选项，将返回 -1，此任务就完成了。可以重复调用 getopt()，直到其返回 -1 为止.

getopt() 所设置的全局变量包括：

optarg——指向当前选项参数（如果有）的指针。
optind——再次调用 getopt() 时的下一个 argv 指针的索引。
optopt——最后一个已知选项。

getopt

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

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <time.h>

/*
    -y:year
    -m:month
    -d:day
    -H hour
    -M:minute
    -S:second

*/
int main(int argc,char *argv[])
{

    FILE*fp = stdout;
    time_t stamp = time(NULL);
    struct tm*tm = localtime(&stamp);
    char timestr[1024];
    int c;
    char fmtstr[32];
    fmtstr[0] = '\0';
    while(1)
    {
        c = getopt(argc,argv,"-H:MSy:md"); //加冒号可以进行修饰字符串，-识别分选项传参
        if(c<0)
            break;
        switch(c)
        {
            case 1:
                if(fp == stdout)
                {
                    fp = fopen(argv[optind-1],"w");
                    if(fp == NULL)
                    {
                        perror("fopen()");
                        fp = stdout;
                    }
                }
                break;
            case 'H':
                if(strcmp(optarg,"12")==0) //optarg是一个全局宏
                    strncat(fmtstr,"%I(%P) ",sizeof(fmtstr)-strlen(fmtstr)-1);
                else if(strcmp(optarg,"24")==0 )
                    strncat(fmtstr,"%H ",sizeof(fmtstr)-strlen(fmtstr)-1);
                else
                    fprintf(stderr,"Invaild argument");
                break;
            case 'M':
            {
                strncat(fmtstr,"%M ",sizeof(fmtstr)-strlen(fmtstr)-1);
                break;
            }
            case 'S':
                strncat(fmtstr,"%S ",sizeof(fmtstr)-strlen(fmtstr)-1);
                break;
            case 'y':
                if(strcmp(optarg,"2")== 0)
                    strncat(fmtstr,"%y ",sizeof(fmtstr)-strlen(fmtstr)-1);
                if(strcmp(optarg,"4")== 0)
                    strncat(fmtstr,"%Y ",sizeof(fmtstr)-strlen(fmtstr)-1);
    
                break;
            case 'm':
                strncat(fmtstr,"%m ",sizeof(fmtstr)-strlen(fmtstr)-1);
                break;
            case 'd':
                strncat(fmtstr,"%d ",sizeof(fmtstr)-strlen(fmtstr)-1);
                break;
            default:
                break;
        }
    }
    strncat(fmtstr,"\n",2);
   strftime(timestr,1024,fmtstr,tm);
   
   fputs(timestr,fp);

    if(fp != stdout)
        fclose(fp);

    return 0;
}

getopt_long

长格式，和上面用法一样。

环境变量

key=value，使用printenv、export可以查看。

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

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

extern char** environ;

int main(int argc,char *argv[])
{
#if 0    
    for(int i=0;environ[i] !=NULL;i++)
    {
        puts(environ[i]);
    }
#endif 
    puts(getenv("USER"));
    setenv("USER","test",1);//0不覆盖  1覆盖
    
    puts(getenv("USER"));
   

    return 0;
}

C程序存储空间布局

64位程序内存空间分布128T,32位内存是4G

pmap命令可以查看。

库

动态库、静态库、手工装载库

       #include <dlfcn.h>

       void *dlopen(const char *filename, int flags);

       int dlclose(void *handle);

       #define _GNU_SOURCE
       #include <dlfcn.h>

       void *dlmopen (Lmid_t lmid, const char *filename, int flags);

       Link with -ldl.

       void *dlsym(void *handle, const char *symbol);
       char *dlerror(void);

函数跳转

   #include <setjmp.h>

       int setjmp(jmp_buf env); 设置跳转点
       int sigsetjmp(sigjmp_buf env, int savesigs);

       void longjmp(jmp_buf env, int val);跳转到指向位置
       void siglongjmp(sigjmp_buf env, int val);
 

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <setjmp.h>

jmp_buf save;

void c()
{

    printf("%s:Begin() \n",__FUNCTION__);
    printf("%s:Jump now! \n",__FUNCTION__);
    longjmp(save,6);

    printf("%s:End() \n",__FUNCTION__);
}

void b()
{

    printf("%s:Begin() \n",__FUNCTION__);

    printf("%s:Call c() \n",__FUNCTION__);
    c();
    printf("%s:c() return \n",__FUNCTION__);
    printf("%s:End() \n",__FUNCTION__);
}

void a()
{
    int ret;
    printf("%s:Begin() \n",__FUNCTION__);
    ret = setjmp(save);
    if(ret ==0)
    {
    
    printf("%s:Call b() \n",__FUNCTION__);
    b();
    printf("%s:b() return \n",__FUNCTION__);
    }
    else
    {
        printf("%s:Jumped back code = %d \n",__FUNCTION__,ret);
    }
    printf("%s:End() \n",__FUNCTION__);
}

int main(int argc,char *argv[])
{
    printf("%s:Begin() \n",__FUNCTION__);
    printf("%s:Call a() \n",__FUNCTION__);
    a();
    printf("%s:a() return \n",__FUNCTION__);

    printf("%s:End() \n",__FUNCTION__);

    return 0;
}

资源的获取及控制

命令：ulimit -a 

getrlimit()：获取资源总量

setrlimit()：设置资源总量

      #include <sys/time.h>
       #include <sys/resource.h>

       int getrlimit(int resource, struct rlimit *rlim);
       int setrlimit(int resource, const struct rlimit *rlim);

       int prlimit(pid_t pid, int resource, const struct rlimit *new_limit,
                   struct rlimit *old_limit);

       struct rlimit {
               rlim_t rlim_cur;  /* Soft limit */ 软限制
               rlim_t rlim_max;  /* Hard limit (ceiling for rlim_cur) */ 硬限制
           };
普通用户不能升级硬限制，root用户可以。软限制不能超过硬限制。

      

only-lucky
关注
专栏目录
C语言编写虚拟文件系统
01-13
使用C语言编写程序，模拟一个简单的文件系统，要求如下： （1） 文件系统的组织结构参考ext2文件系统 （2） 创建一个“disk.os”文件，大小为4MB，用该文件模拟外存。 （3） 最后应生成一个可执行文件“myfs”，...
C语言-文件操作
qq_37746855的博客
03-22 1188
什么是文件 磁盘上的文件是文件。 但是在程序设计中，我们一般谈的文件有两种：程序文件、数据文件 程序文件 包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows环境后缀为.exe）。 数据文件 文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。 本章讨论的是数据文件。 在以前各章所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。 其实有时候我们会把信息输出到磁盘上，当
C语言文件函数详解
欢迎交流！
06-12 5525
一、文件的打开和关闭1、文件指针 2、文件打开和关闭二、文件的顺序读写1、fgetc()和fputc()函数 2、fgets()和fputs()函数 3、fscanf()和fprintf()函数 4、fread()和fwrite()函数三、文件的随机读写1、fseek函数 2、ftell函数 3、fwind函数每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名字，文件状态及文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是有系统声明的，取名FILE。
c++实现的十分简易文件系统
little_qi的博客
06-27 2万+
课题作业任务：在内容中开辟一个100M的空间作为磁盘空间，在此上模拟创建一个文件管理系统。 本系统已经实现的相关操作： 所有操作都不支持从根目录索引，即都只能访问当前目录下的文件，不能用/a/b越级访问 1）目录相关操作 列出目录下所有文件：ls 切换目录：cd newdir 显示目录：pwd 创建目录：mkdir dirName 删除目录和目录下所有文件：rmdir dirN
基于C语言的小型文件系统设计与实现
毕业作品网站
03-12 1万+
科技的进步已将人类带入了信息大爆炸的时代，随着计算机科学技术的不断发展，计算机成为了许多人日常生活中必不可少的一部分，不管是个人办公娱乐还是企业员工协作，都无一不用到了计算机的信息管理、文件管理技术，其中文件系统就是计算机上有着良好功能设计的一个系统、它通过良好的文件信息组织和简便的功能操作，提供强大文件管理功能的同时，还给予了使用者莫大的便捷。因此，此系统的应运而生可以解决了文件的信息管理问题，推动了当时计算机科学技术的深入发展。
C语言模拟实现Linux文件系统
09-12
C语言模拟实现Linux文件系统 1、在内存中开辟一块空间来模拟文件系统的运行，不读写硬盘。 2、面向单用户、单任务，不考虑并发，不考虑文件属主、组等概念。 3、程序开始后，初始化并接收用户输入。若输入”enter”...
操作系统c语言模拟文件管理系统
02-13
这些函数会将文件从文件系统中移除，释放其所占用的空间。在实际操作系统中，文件删除可能会涉及权限检查和垃圾回收机制。 3. **文件打开和关闭**：`fopen()`函数不仅可以用来创建文件，还可以用于打开已存在的文件...
C语言实现操作系统的文件系统操作
06-09
切换目录、创建文件、删除文件、写入内容、重写内容、创建目录、删除目录、显示当前目录下所有子目录和子文件、查找文本内容、复制文件、复制子目录和文件、导入文件、导出文件、显示文件内容、保存磁盘数据、帮助...
C语言：从为什么要学C语言到文件操作
03-18
在C语言中，文件操作是通过标准I/O库提供的函数完成的，主要包括打开文件、读写文件、关闭文件等操作。 1. 打开文件：使用`fopen()`函数打开文件。例如： ```c FILE *fp; fp = fopen("example.txt", "r"); // "r...
文件系统实验，c语言代码，filesystem
07-22
包括文件系统程序，c语言代码 操作系统实验。
c 文件系统
SUPER7D的博客
07-31 411
c
C语言与嵌入式文件系统：FatFS、LittleFS等嵌入式文件系统的使用与定制（二）
最新发布
weixin_56154577的博客
04-16 1030
如果嵌入式系统资源极为有限（如RAM、ROM），LittleFS通常比FatFS占用资源更少，并且对小容量存储有更好的支持。
【Linux】C文件系统详解（三）——如何理解缓冲区以及自主封装一个文件接口
patrick的博客
11-19 305
所以真正的调用顺序应该是:在fork之前,write就直接打印进文件了,但是fwrite只是写在缓冲区中.在fork之后,fwrite的缓冲区中的文件变成了两份(写时拷贝),由此,会出现打印两次的现象.(下图中有解释)在你进行fopen打开文件的时候,会得到一个FILE结构体,缓冲区就在该结构体中。以前写过一个进度条, 有一个输出缓冲区->这个缓冲区在哪里,为什么要存在。而调用write时,是系统调用,没有缓冲区,会直接刷新出来。1.历史上我们所谈的缓冲区指的是:用户级缓冲区,语言提供。
Linux常用C函数—文件内容操作篇
tuyerv的博客
06-20 514
clearerr（清除文件流的错误旗标） 相关函数 feof表头文件 #include定义函数 void clearerr(FILE * stream);函数说明 clearerr（）清除参数stream指定的文件流所使用的错误旗标。返回值 　 fclose（关闭文件） 相关函数 close，fflush，fopen，setbuf表头文件 #include定义函数 int fclos...
C语言文件操作超详解（万字解读，细致入微）
热门推荐
m0_70811813的博客
10-12 3万+
什么是文件、文件名、文件的打开和关闭、文件的读写、文本文件和二进制文件、文件读取结束的判定、文件缓冲区
操作系统课程设计---简单文件系统C语言实现
C/C++学习之旅
03-11 1543
本文是分享一个简易文件系统的实现
C 语言文件操作函数大全 (超详细)
coder_Alger 的博客
06-30 1040
fopen（打开文件） 相关函数 fopen，fclose 表头文件 # include 定义函数 FILE * fopen (const char * path,const char * mode); 函数说明 参数 path 字符串包含欲打开的文件路径及文件名，参数 mode 字符串则代表着流形态。注意：上述的形态字符串都可以再加一个 b 字符，如 rb、w+b 或 ab＋等组合，加入 b 字符用来告诉函数库打开的文件为二进制文件，而非纯文字文件。不过在 POSIX 系统，包含 Lin...
文件（C语言）
qq_57656148的博客
09-07 2849
1.文件(file) 指存储在外部介质上数据的集合，比如我们经常使用的txt、bmp、 jpg、 exe、 rmvb 等等。这些文件各有名的用途，我们通常将它们存放在磁盘或者可移动盘等介质中。 文件无非就是一段数据的集合，这些数据可以是有规则的集合，也可以是无序的集合。操作系统也就是以文件为单位对数据进行管理的。也就是说，要访问外部介质上的数据,必须先按照文件名进行查找，然后从该文件中读取数据。要想写数据到外部介质，必须得建立-个文件，然后再写入。 2.文件一般包括三要素:文件路径、文件名、后缀。 由于在C
C语言编程：文件操作详解
"C语言文件部分课件，涵盖了文件的概述、文件类型指针、文件的打开与关闭、文件的读写、文件的定位等内容，旨在帮助理解和掌握C语言中的文件操作。" 在C语言中，文件操作是程序与外部存储交互的关键手段。第10章...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值