文件IO 用法小结

最新推荐文章于 2024-06-03 16:35:19 发布
最新推荐文章于 2024-06-03 16:35:19 发布
阅读量55 收藏
点赞数
文章标签： linux 服务器 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45812901/article/details/129262827
版权

标准C库IO函数

在这里插入图片描述
标准c库的io函数开发的东西可以跨平台
标准c库io函数，带有缓冲区，能够提高效率（linux系统io函数没有缓冲区）

标准C库IO和Linux系统IO的关系

调用与被调用的关系
在这里插入图片描述

虚拟地址空间

在这里插入图片描述

文件描述符

在这里插入图片描述

Linux系统IO函数

在这里插入图片描述

open函数的使用

使用open函数打开一个文件

/*
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

//打开一个已经存在的文件
int open(const char *pathname,int flags);

    参数：
        pathname：要打开的文件路径
        flags：对文件的操作权限设置还有其他的设置
        O_RDONLY,  O_WRONLY,  O_RDWR   这三个设置是互斥的
    返回值：返回一个新的文件描述符，如果调用失败，返回-1

    errno:属于Linux系统函数库，库里面的一个全局变量，记录的是最近的错误号。

    #include<stdio.h>
    void perror(const char *s); //作用：打印errno对应的错误描述
        s参数：用户描述，比如hello，最终输出的内容是 hello：xxx（实际的错误描述）


//创建一个新的文件
int open(const char *pathname,int flags,mode_t mode);

*/

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

int main(){

    //打开一个文件
    int fd = open("a.txt",O_RDONLY);

    if(fd == -1){
        perror("open");
    }
    //读写操作


    //关闭
    close(fd);

    return 0;
}

使用open函数创建文件

/*
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

//创建一个新的文件
int open(const char *pathname,int flags,mode_t mode);
    参数：
        pathname：要创建的文件的路径
        flags：对文件的操作权限和其他的设置
            必选项：O_RDONLY, O_WRONLY, O_RDWR 这三个是互斥的
            可选项：O_CREAT 文件不存在，创建新文件
        mode：八进制的数，表示创建出的新的文件的操作权限，比如 0775 
        最终的权限是： mode & ~umask

        读 写 执行            当前用户对文件的权限  当前用户所在组      其他组
        r  w   x                     rwx                rwx            rwx
           7                          7                  7              7

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

int main(){
    int fd = open("create.txt",O_RDWR | O_CREAT,0777);

    if(fd == -1){
        perror("open");
    }
    close(fd);
    return 0;
}

调用read和write函数实现文件复制功能

/*
    #include<unistd.h>
    ssize_t read(int fd,void *buf,size_t count);
        参数：
            fd：文件描述符，open得到的，通过这个文件描述符操作某个文件
            buf：需要读取数据存放的地方，数组的地址
            count：指定的数组的大小
        返回值：
            成功：
                >0：返回实际的读取到的字节数
                =0：文件已经读取完了
            失败：-1，并且设置errno

    #include<unistd.h>
    ssize_t write(int fd,const void *buf,size_t count);
    参数：
            fd：文件描述符，open得到的，通过这个文件描述符操作某个文件
            buf：要往磁盘写入的数据，
            count：要写的数据的实际的大小
        返回值：
            成功：返回被写入的实际的字节数
            失败：-1，并且设置errno
*/
#include<unistd.h>
#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
int main(){

    //1、通过open打开english文件
    int srcfd = open("english.txt",O_RDONLY);
    if(srcfd == -1){
        perror("open");
        return -1;
    }
    //2、创建一个新的文件（拷贝文件）
    int destfd = open("copy.txt",O_WRONLY | O_CREAT,0664);
    if(destfd == -1){
        perror("open");
        return -1;
    }
    //3、频繁的独写操作
    char buf[1024] = {0};
    int len = 0;
    
    while((len = read(srcfd,buf,sizeof(buf)))>0){
        write(destfd,buf,len);
    }
    //4、关闭文件
    close(destfd);
    close(srcfd);

    return 0;
}

通过ll，我们可以发现copy.txt和english.txt字节数是一样的
在这里插入图片描述
lseek的使用

/*
    标准C库的函数
    #include<stdio.h>
    int fseek(FIFO *stream,long offset,int whence);

    Linux系统函数
    #include<sys/types.h>
    #include<unistd.h>
    off_t lseek(int fd,off_t offset,int whence);
        参数：
            fd：文件描述符，通过open得到，通过这个fd操作某个文件
            offset：偏移量
            whence：
                SEEK_SET
                    设置文件指针的偏移量
                SEEK_CUR
                    设置偏移量：当前位置+第二个参数offset的值
                SEEK_END
                    设置偏移量：文件大小+第二个参数offset的值
        返回值：
            返回文件指针的位置


    作用：
        1、移动文件指针到文件头
        lseek(fd,0,SEEK_SET);

        2、获取当前文件指针的位置
        lseek(fd,0,SEEK_CUR);

        3、获取文件长度
        lseek(fd,0,SEEK_END);

        4、扩展文件的长度，当前文件10b，110b，增加了100个字节
        lseek(fd,100,SEEK_END);
        注意：需要写一次数据才管用

*/

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

int main(){
    int fd = open("hello.txt",O_RDWR);
    if(fd == -1){
        perror("open");
        return -1;
    }

    int lk= lseek(fd,100,SEEK_END);
    if(lk==-1){
        perror("lseek");
        return -1;
    }

    //写入一个空数据，不然虽然扩展成功了，但是没人用，还是显示之前的字节数
    write(fd," ",1);

    close(fd);

    return 0;
}

我们可以看到，在未扩展文件之前是11个字节，扩展之后变成了112个字节，分别是原来的十一个字节+扩展的100个字节+写入的一个字节
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
stat的应用

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

    int stat(const char *pathname, struct stat *statbuf);
        作用：获取一个文件相关的一些信息
        参数:
            - pathname：操作的文件的路径
            - statbuf：结构体变量，传出参数，用于保存获取到的文件的信息
        返回值：
            成功：返回0
            失败：返回-1 设置errno

    int lstat(const char *pathname, struct stat *statbuf);
        参数:
            - pathname：操作的文件的路径
            - statbuf：结构体变量，传出参数，用于保存获取到的文件的信息
        返回值：
            成功：返回0
            失败：返回-1 设置errno

*/

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

int main(){
    struct stat statbuf;

    int ret = stat("a.txt",&statbuf);

    if(ret == -1){
        perror("stat");
        return -1;
    }

    printf("size: %ld\n", statbuf.st_size);

    return 0;
   
}

通过stat获取文件的信息，来实现ls的功能

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

//模拟实现ls -l 指令
int main(int argc, char *argv[]){

    if(argc<2){
        printf("%s filename\n", argv[0]);
        return -1;
    }

    //通过stat函数获取用户传入的文件信息
    struct stat st;
    int ret = stat(argv[1],&st);
    if(ret == -1){
        perror("stat");
        return -1;
    }

    //获取文件类型和文件权限
    char perms[11] = {0}; //用于保存文件类型和文件权限的字符串

    switch(st.st_mode & S_IFMT) {
        case S_IFLNK:
            perms[0] = 'l';
            break;
        case S_IFDIR:
            perms[0] = 'd';
            break;
        case S_IFREG:
            perms[0] = '-';
            break; 
        case S_IFBLK:
            perms[0] = 'b';
            break; 
        case S_IFCHR:
            perms[0] = 'c';
            break; 
        case S_IFSOCK:
            perms[0] = 's';
            break;
        case S_IFIFO:
            perms[0] = 'p';
            break;
        default:
            perms[0] = '?';
            break;
    }

    // 判断文件的访问权限

    // 文件所有者
    perms[1] = (st.st_mode & S_IRUSR) ? 'r' : '-';
    perms[2] = (st.st_mode & S_IWUSR) ? 'w' : '-';
    perms[3] = (st.st_mode & S_IXUSR) ? 'x' : '-';

    // 文件所在组
    perms[4] = (st.st_mode & S_IRGRP) ? 'r' : '-';
    perms[5] = (st.st_mode & S_IWGRP) ? 'w' : '-';
    perms[6] = (st.st_mode & S_IXGRP) ? 'x' : '-';

    // 其他人
    perms[7] = (st.st_mode & S_IROTH) ? 'r' : '-';
    perms[8] = (st.st_mode & S_IWOTH) ? 'w' : '-';
    perms[9] = (st.st_mode & S_IXOTH) ? 'x' : '-';

    //硬连接数
    int linkNum = st.st_nlink;

    //文件所有者
    char *fileUser = getpwuid(st.st_uid) ->pw_name;

    //文件所在组
    char * fileGRrp = getgrgid(st.st_gid)->gr_name;

    //文件大小
    long int fileSize = st.st_size;

    //获取修改的时间
    char *time = ctime(&st.st_mtime);

    //不让他换行
    char mtime[512]={0};
    strncpy(mtime,time,strlen(time)-1);

    char buf[1024];
    sprintf(buf,"%s %d %s %s %ld %s %s",perms,linkNum,fileUser,fileGRrp,fileSize,mtime,argv[1]);

    printf("%s\n",buf);
    return 0;
}

在这里插入图片描述

文件属性操作函数

在这里插入图片描述
使用access判断文件是否存在

/*
    #include<unistd.h>
    int access(const char *pathname,int mode);
        作用：判断某个文件是否有某个权限，或者判断文件是否存在
        参数：
            pathname：判断的文件路径
            mode：
                R_OK：判断是否有读权限
                W_OK：判断是否有写权限
                X_OK：判断是否有执行权限
                F_OK：判断文件是否存在
            返回值：成功返回0，失败返回-1
*/
#include<unistd.h>
#include<stdio.h>

int main(){
    int ret = access("a.txt",F_OK);
    if(ret == -1){
        perror("access");
        return -1;
    }
    printf("文件存在！！！！ \n");
    return 0;
}

chmod修改文件的权限

/*
    #include<sys/stat.h>
    int chmod(const char *pathname,mode_t mode);
    修改文件的权限
    参数：
        pathname：需要修改的文件的路径
        mode：需要修改的权限值，八进制的数
    返回值：成功返回0，失败返回-1
*/
#include<sys/stat.h>
#include<stdio.h>
int main(){
    int ret = chmod("a.txt",0775);
    if(ret == -1){
        perror("ret");
        return -1;
    }

    printf("修改成功！！！\n");
    return 0;
}

chown修改文件所在组
使用useradd增加一个用户，然后把a.txt所有者和所在组改为gaogao
在这里插入图片描述

/*
    #include<unistd.h>
    int chown(const char *pathname, uid_t owner, gid_t group);
    参数：
        owner：所有者的id
        group：所在组的id
    所有者和所在组的id可以通过 vim /etc/passwd 命令查看
    只查看所在组： vim /etc/group

*/

#include<unistd.h>
#include<stdio.h>

int main(){
    int ch = chown("a.txt",1001,1001);
    if(ch == -1 ){
        perror("chown");
        return -1;
    }
    printf("修改成功\n");
    return 0;
}

在这里插入图片描述
使用truncate缩减或者扩展文件的尺寸至指定的大小

/*
    #include<unistd.h>
    #include<sys/types.h>
    int truncate(const char *path,off_t length);
        作用：缩减或者扩展文件的尺寸至指定的大小
        作用：
            path：需要修改的文件的路径
            length：需要最终文件变成的大小
*/
#include<unistd.h>
#include<sys/types.h>
#include<stdio.h>
int main(){
    int tc = truncate("b.txt",20);
    if(tc == -1){
        perror("truncate");
        return -1;
    }

    printf("success\n");
    return 0;
}

在这里插入图片描述

目录操作函数

在这里插入图片描述

  • mkdir：创建一个目录
  • rmdir：删除一个空文件
  • rename：对目录重命名
  • chdir：更改当前目录的当前路径
  • getcwd：获取当前路径
/*
    #include <sys/stat.h>
    #include <sys/types.h>
    int mkdir(const char *pathname, mode_t mode);
        作用：创建一个目录
        参数：
            pathname: 创建的目录的路径
            mode: 权限，八进制的数
        返回值：
            成功返回0， 失败返回-1
*/

#include<sys/stat.h>
#include<sys/types.h>
#include<stdio.h>
int main(){
    int ret=mkdir("aaa",0777);
    if(ret == -1){
        perror("mkdir");
        return -1;
    }
    return 0;
}

注意：一个目录必须具有可执行文件，才能进入文件

/*
    #include <stdio.h>
    int rename(const char *oldpath, const char *newpath);

*/
#include <stdio.h>

int main() {

    int ret = rename("aaa", "bbb");

    if(ret == -1) {
        perror("rename");
        return -1;
    }

    return 0;
}

chdir修改工作目录
getcwd：获取当前路径

/*

    #include <unistd.h>
    int chdir(const char *path);
        作用：修改进程的工作目录
            比如在/home/nowcoder 启动了一个可执行程序a.out, 进程的工作目录 /home/nowcoder
        参数：
            path : 需要修改的工作目录

    #include <unistd.h>
    char *getcwd(char *buf, size_t size);
        作用：获取当前工作目录
        参数：
            - buf : 存储的路径，指向的是一个数组（传出参数）
            - size: 数组的大小
        返回值：
            返回的指向的一块内存，这个数据就是第一个参数

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

int main(){
    //获取当前的工作目录
    char buf[128];
    getcwd(buf,sizeof(buf));
    printf("当前工作目录是：%s\n",buf);

    //修改工作目录
    int ret = chdir("/home/nowcoder/Linux/lesson13");
    if(ret == -1){
        perror("chdir");
        return -1;
    }

    //创建一个新的文件
    int fd = open("chdir.txt",O_CREAT | O_RDWR,0664);
    if(fd == -1){
        perror("open");
        return -1;
    }
    close(fd);

    //获取当前的工作目录
    char buf1[128];
    getcwd(buf1,sizeof(buf1));
    printf("当前工作目录是：%s\n",buf1);

    return 0;
}

目录遍历函数

  • opendir：打开一个目录
  • readdir：读取目录里的内容
  • closedir：关闭目录

在这里插入图片描述

/*
    // 打开一个目录
    #include <sys/types.h>
    #include <dirent.h>
    DIR *opendir(const char *name);
        参数：
            - name: 需要打开的目录的名称
        返回值：
            DIR * 类型，理解为目录流
            错误返回NULL


    // 读取目录中的数据
    #include <dirent.h>
    struct dirent *readdir(DIR *dirp);
        - 参数：dirp是opendir返回的结果
        - 返回值：
            struct dirent，代表读取到的文件的信息
            读取到了末尾或者失败了，返回NULL

    // 关闭目录
    #include <sys/types.h>
    #include <dirent.h>
    int closedir(DIR *dirp);

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

int getFileNum(const char *path);

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

    if(argc<2){
        printf("%s path\n", argv[0]);
        return -1;
    }

    int num = getFileNum(argv[1]);
    printf("普通文件的个数：%d\n",num);

    return 0;

}

//用于获取目录下所有普通文件的个数
int getFileNum(const char *path){
    //1、打开目录
    DIR *dir = opendir(path);

    if(dir == NULL){
        perror("opendir");
        exit(0);
    }

    struct dirent *ptr;
    
    //记录普通文件的个数
    int total = 0;

    while((ptr = readdir(dir)) != NULL){
        //获取名称
        char *dname = ptr->d_name;


        //忽略掉.和..
        //strcmp(str1,str2) str1=str2则返回0  str1>str2则返回大于0的值  str1<str2则返回小于0的值 
        if(strcmp(dname,".")==0 || strcmp(dname,"..")==0){
            continue;
        }

        //判断是否是普通文件还是目录
        if(ptr->d_type == DT_DIR){
            //目录，需要继续读取这个目录
            char newpath[256];
            sprintf(newpath,"%s/%s",path,dname);
            total += getFileNum(newpath);
        }

        if(ptr->d_type == DT_REG){
            //普通文件
            total++;
        }

    }
    
    //关闭目录
    closedir(dir);

    return total;

}

在这里插入图片描述
在这里插入图片描述

/*
    #include <unistd.h>
    int dup(int oldfd);
        作用：复制一个新的文件描述符
        fd=3, int fd1 = dup(fd),
        fd指向的是a.txt, fd1也是指向a.txt
        从空闲的文件描述符表中找一个最小的，作为新的拷贝的文件描述符


*/

#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
int main(){
    int fd = open("a.txt", O_CREAT | O_RDWR,0664);
    int fd1 = dup(fd);
    if(fd1 == -1){
        perror("dup");
        return -1;
    }
    printf("fd: %d , fd1: %d \n",fd,fd1);
    close(fd);

    char *str="hello,world";
    int ret = write(fd1,str,strlen(str));
    if(ret == -1){
        perror("write");
        return -1;
    }
    close(fd1);
    return 0;
}

dup2

/*
    #include <unistd.h>
    int dup2(int oldfd, int newfd);
        作用：重定向文件描述符
        oldfd 指向 a.txt, newfd 指向 b.txt
        调用函数成功后：newfd 和 b.txt 做close, newfd 指向了 a.txt
        oldfd 必须是一个有效的文件描述符
        oldfd和newfd值相同，相当于什么都没有做
*/
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>

int main() {

    int fd = open("1.txt", O_RDWR | O_CREAT, 0664);
    if(fd == -1) {
        perror("open");
        return -1;
    }

    int fd1 = open("2.txt", O_RDWR | O_CREAT, 0664);
    if(fd1 == -1) {
        perror("open");
        return -1;
    }

    printf("fd : %d, fd1 : %d\n", fd, fd1);

    int fd2 = dup2(fd, fd1);
    if(fd2 == -1) {
        perror("dup2");
        return -1;
    }

    // 通过fd1去写数据，实际操作的是1.txt，而不是2.txt
    char * str = "hello, dup2";
    int len = write(fd1, str, strlen(str));

    if(len == -1) {
        perror("write");
        return -1;
    }

    printf("fd : %d, fd1 : %d, fd2 : %d\n", fd, fd1, fd2);

    close(fd);
    close(fd1);

    return 0;
}

在这里插入图片描述

/*

    #include <unistd.h>
    #include <fcntl.h>

    int fcntl(int fd, int cmd, ...);
    参数：
        fd : 表示需要操作的文件描述符
        cmd: 表示对文件描述符进行如何操作
            - F_DUPFD : 复制文件描述符,复制的是第一个参数fd，得到一个新的文件描述符（返回值）
                int ret = fcntl(fd, F_DUPFD);

            - F_GETFL : 获取指定的文件描述符文件状态flag
              获取的flag和我们通过open函数传递的flag是一个东西。

            - F_SETFL : 设置文件描述符文件状态flag
              必选项：O_RDONLY, O_WRONLY, O_RDWR 不可以被修改
              可选性：O_APPEND, O)NONBLOCK
                O_APPEND 表示追加数据
                NONBLOK 设置成非阻塞
        
        阻塞和非阻塞：描述的是函数调用的行为。
*/

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>

int main() {

    // 1.复制文件描述符
    // int fd = open("1.txt", O_RDONLY);
    // int ret = fcntl(fd, F_DUPFD);

    // 2.修改或者获取文件状态flag
    int fd = open("1.txt", O_RDWR);
    if(fd == -1) {
        perror("open");
        return -1;
    }

    // 获取文件描述符状态flag
    int flag = fcntl(fd, F_GETFL);
    if(flag == -1) {
        perror("fcntl");
        return -1;
    }
    flag |= O_APPEND;   // flag = flag | O_APPEND

    // 修改文件描述符状态的flag，给flag加入O_APPEND这个标记
    int ret = fcntl(fd, F_SETFL, flag);
    if(ret == -1) {
        perror("fcntl");
        return -1;
    }

    char * str = "nihao";
    write(fd, str, strlen(str));

    close(fd);

    return 0;
}
一直特立独行的橙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
linux文件io实训小结,Linux下5种IO模型的小结
weixin_36460310的博客
05-07 253
概述接触网络编程，我们时常会与各种与IO相关的概念打交道：同步(Synchronous)、异步(ASynchronous)、阻塞(blocking)和非阻塞(non-blocking)。关于概念的区别在知乎上看到一位朋友(链接)打了一个比较形象的比喻：你打电话问书店老板有没有《分布式系统》这本书，如果是同步通信机制，书店老板会说，你稍等，”我查一下"，然后开始查啊查，等查好了(可能是5秒，也可能是...
php高级IO用法
藏经阁
08-05 1131
无论哪种编程语言，IO操作都值得好好学习和理解。由于PHP简单的特性，不少人对此毫无概念也能写出可用的代码。本文总结PHP开发中几个常见的IO场景并介绍对应的操作，希望能帮助PHP开发人员加深对IO的理解。后续文章中将介绍隐藏在简单之下的本质：流。 本文介绍的场景包括：读写文件、命令行输入输出、与远程网址交互。废话少说，直接开始吧！ 一、读写文件 文件的读写是最常规的IO操作。打开文件、读写...
【IO操作】标准IO和文件IO
Atcxr的博客
05-02 902
主要介绍了标准 I/O 和文件 I/O 的区别，以及关于这两种 I/O 操作的详细介绍。标准 I/O 是基于 C 语言的库函数，而文件 I/O 是基于 Linux 系统调用的操作。文章分析了它们的区别，包括在跨平台性、系统调用频率以及文件描述符和文件指针等方面的不同。此外，文章总结了标准 I/O 和文件 I/O 中常用的函数、参数、返回值和常见用法，并提供了示例代码以便加深理解。
标准IO及其各函数用法
qq_45570844的博客
05-15 1728
标准IO各函数：fgetc函数、fputc函数、fgets函数、fputs函数、fread函数、fwrite函数、fopen函数、fclose函数、perror函数、fseek函数、ftell函数、rewind函数 利用标准IO的读写操作，完成文本复制，模拟了虚拟机CP命令，附有详细代码展示
java 文件io,[Java] 在Java中优雅地进行文件IO操作
weixin_39832628的博客
03-11 102
Java IO 相关的类确实很多，但我们并不是所有的类都会用到，我们常用的也就是文件相关的几个类，如文件最基本的读写类 File 开头的、文件读写带缓冲区的类 Buffered 开头的类，对象序列化反序列化相关的类 Object 开头的类。下面用几个例子来介绍Java IO的基础用法，二进制流的读写 与 字符流的读写1.二进制流读写import java.io.*;import java.nio....
socket.io的基本用法
cangqiong_xiamen的博客
08-22 952
今天用nodejs和socket.io实现在线聊天功能。总结一下socket.io的基本用法 首先安装socket包 npm install socket.io 在服务器端引用 const socketio = require("socket.io"); 安装完包，引用这个socket的js文件 。他的路径node_modules/socket.io-client/dist/socket.io.js 在客户端，即index.html文件中引用 <script src="js/sock
【Linux】深入理解文件IO操作
杨翔裕的博客
11-29 1875
一、如何用C接口进行文件操作 i. 基础函数 FILE *fopen(const char *path, const char *mode);//打开函数 int fclose(FILE *fp);//关闭函数 size_t fread ( void *buffer, size_t size, size_t count, FILE *stream);//读取函数 size_t fwrite(const void* buffer, size_t size, size_t count, FILE* stream
Java之文件操作与IO
tq02的博客
09-05 5609
本文详细讲解了io操作和文件操作，从认识到掌握，还有Reader和Writer类、FileInputStream类和FileOutputStream类的讲解
Common IO 使用小结
m0_38018775的博客
03-12 6579
转 【跟我学apache-commons】【四】commons-io的使用 2015年07月03日 16:43:34 chenjazz 阅读数：6980 ...
操作Zip压缩文件流的用法总结
m0_60982956的博客
05-30 1396
1.概述 ZipInputStream是一种FilterInputStream，它可以直接读取zip包的内容： ┌───────────────────┐ │ InputStream │ └───────────────────┘ ▲ │ ┌───────────────────┐ │ FilterInputStream │ └───────────────────┘ ▲ │ ┌────────────────
文件IO编程总结
08-06
自己总结的文件IO函数，和比较常用的用法，尤其适合初学者。
commons-io-2.CHM
04-07
因此，对于方法的用法总结如下： 1. buffer方法：将传入的流进行包装，变成缓冲流。并可以通过参数指定缓冲大小。 2. closeQueitly方法：关闭流。 3. contentEquals方法：比较两个流中的内容是否一致。 4. copy...
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
2、常用21个IO流：FileWriter、FileReader、CharArrayReader、CharArrayWriter、CharSequence、OutputStreamWriter、FileOutputStream、InputStreamReader...演示错误用法和经典用法。 4、代码的结构可查看README文件。
C++读取特定路径下文件目录及文件名称
12-22
　查了下C++的资料，发现有很多方法，这里总结其中的一种，其他用法类似。 　主要用到了以下几个头文件(类)：io.h， fstream， string。 　1、读取某给定路径下所有文件夹与文件名称，并带完整路径。代码如下： ...
Python常见读写文件操作实例总结【文本、json、csv、pdf等】
01-21
读写文件是最常见的IO操作,python内置了读写文件的函数,用法和c是兼容的. 读写文件前,我们必须了解一下,在磁盘上读写文件的功能都是由操作系统提供的,现代操作系统不允许普通的程序直接操作磁盘,所以读写文件就是...
Linux CFS调度器简介
小立仔
05-30 801
Linux CFS调度器简介
CentOS 7基础操作05_Linux查看及切换目录
IT_zhangsan
05-31 1106
pwd命令用于显示用户当前所在的工作目录位置,工作目录是用户操作文件或其他子目录的默认位置起点。使用pwd命令可以不添加任何选项或参数。
linux 之dma_buf (4)- mmap
z20230508的博客
05-28 934
前面几篇都是在 kernel space 对 dma-buf 进行访问的，本篇我们将一起来学习，如何在 user space 访问 dma-buf。当然，user space 访问 dma-buf 也属于 CPU Access 的一种。
【linux】无root权限下载7z解压软件并安装到指定路径
最新发布
weixin_44502754的博客
06-03 283
【linux】无root权限下载7z解压软件并安装到指定路径
BufferedReader 用法
08-02
BufferedReader是一个用于读取文件或接收键盘输入信息的类。它比Scanner更快捷，可以大幅度缩短程序运行时间。使用BufferedReader时，可以使用其readLine()方法一次性读取一行文字（String），非常方便。需要注意的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值