1.17-1.30 文件IO

已于 2023-03-20 18:10:48 修改
阅读量168 收藏
点赞数
分类专栏： webserver 文章标签： linux 运维 服务器
于 2023-03-14 22:27:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41581765/article/details/129541374
版权

1. 标准C库IO函数 vs Linux系统IO函数

一言以蔽之，标准C库IO函数 和 Linux系统IO函数 就是 调用 与 被调用 的关系。标准C库IO函数更加高级，效率更高； Linux系统IO函数更偏向底层。
在这里插入图片描述

Linux自带的一个查看帮助文档命令

man 3 fopen

结构体解释

  1. 文件描述符：也叫文件句柄，它的作用是找到这个文件
  2. 文件读写指针：操作文件的数据
  3. I/O缓冲区：写入的数据先写到文件缓冲区里，等到满了之后，调用linux的函数，再写的磁盘里面，作用提高执行的效率，频繁操作硬件效率低

什么场景适合使用缓冲区？什么场景不适合？

当进行网络通信的时候，不能把通信信息放在缓冲区，会影响交流的效率；应该使用linux的IO函数
当进行磁盘读写的时候，需要先放在缓冲区里，减少磁盘的IO；应该使用C库的IO函数
在这里插入图片描述

2. 虚拟地址空间

文件描述符
在这里插入图片描述
程序运行之后，也就是进程，系统会为他分配一个虚拟地址空间。
进程：运行的程序，会被加载到内存里面，资源分配的单位。
在这里插入图片描述
虚拟地址空间会被内存管理单元MMU映射到物理内存上面。
4G = 3G用户区+1G内核区

  • 堆空间：从低地址向高地址生长；
  • 栈空间：从上向下生长。
    用户一般不能读写内核区的数据，通过系统调用对内核区的数据进行操作

3. 文件描述符

在这里插入图片描述

提问：为什么调用fread/fwrite以后，它就能找到english.txt文件进行读写呢？

调用fread/fwrite之后，会返回一个封装文件描述符的file指针，这样他就能找到这个文件。
这个文件描述符就在进程的内核区
在这里插入图片描述
内核就是一个程序，PCB就是一个复杂的结构体，把需要管理的数据封装在PCB里。PCB管理文件描述符表，文件描述符表是一个数组。每个文件描述符都对应一个文件，如果同时打开多个文件的情况，需要数组进行管理。
文件描述符表默认大小是1024，因此每个进程最大能同时打开的文件个数就是1024。
文件描述符表前3个默认分别是：标准输入、标准输出、标准错误。默认指向当前设备文件终端。

“一切皆文件”，硬件设备的也是一个设备文件。

打开：一个文件可以被打开多次，但是返回的文件描述符是不一样的。占用的事空闲的最小的一个文件描述符。
关闭：使用close函数，可以释放这个文件描述符。
调用Linux的文件IO函数传递的就是文件描述符，而不是C库函数的文件指针了。

4. open打开文件

在这里插入图片描述

man 2 open

man 2是linux，在第二章；man 3是C库函数，在第三章

/*
    #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;
}

5. 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   umask, user（普通用户）: 0002  root: 0022
            0777   ->   111111111
        &   0775   ->   111111101
        ----------------------------
                        111111101
        按位与：0和任何数都为0
        umask的作用就是抹去某些权限。

        flags参数是一个int类型的数据，占4个字节，32位。
        flags 32个位，每一位就是一个标志位。

*/
#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;
}

Linux文件权限讲解

0 rwx rwx rwx 10位数，3个一组，第一组是当前用户对文件的权限，第二组是当前组的权限，第三组是其他组。
0777，即0111 111 111，3组权限都有的意思。这里是8进制数。

umask，抹去某些权限

6. read、write函数

创建一个大小为129772的文本文件，english.txt
在这里插入图片描述
内容长这样
在这里插入图片描述

/*  
    #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.txt文件
    int srcfd = open("english.txt", O_RDONLY);
    if(srcfd == -1) {
        perror("open");
        return -1;
    }

    // 2.创建一个新的文件（拷贝文件）
    int destfd = open("cpy.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;
}

7. lseek函数

/*  
    标准C库的函数
    #include <stdio.h>
    int fseek(FILE *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 ret = lseek(fd, 100, SEEK_END);
    if(ret == -1) {
        perror("lseek");
        return -1;
    }

    // 写入一个空数据
    write(fd, " ", 1);

    // 关闭文件
    close(fd);

    return 0;
}

问题：拓展完之后如果不写入为什么字节数不增加呢

拓展时，lseek只是逻辑上移动文件指针的位置，并没有为文件分配存储空间，为了让这些空间实际得到分配，可以使用write在最后补充一个字符，这样拓展的存储空间应该就分配了。——来自牛油解释

8. stat、lstat函数

在这里插入图片描述

stat.c

/*
    #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;
}

创建软链接
在这里插入图片描述
在这里插入图片描述
vim b.txt打开的是a.txt

ln -s a.txt b.txt

stat与lstat的区别：
stat输出文件的信息；lstat输出软链接文件的信息

在这里插入图片描述
在这里插入图片描述
一共7种文件类型。

  1. 与S_IFMT做按位与操作，得到st_mode的前4位字符；
  2. 接下来与7种宏作比较，匹配上了就是该文件类型。

文件类型：用1个或2个标志位，使用掩码计算
获取的样例代码

// 获取文件类型和文件权限
    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;
    }

9. 模拟实现ls -l命令

ls -l a.txt

输出文件a.txt的信息
在这里插入图片描述


#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 指令
// -rw-rw-r-- 1 nowcoder nowcoder 12 12月  3 15:48 a.txt
int main(int argc, char * argv[]) {

    // 判断输入的参数是否正确
    if(argc < 2) {
        printf("%s filename\n", argv[0]);
        return -1;
    }

    // 通过stat函数获取用户传入的文件的信息
    // 传入stat类型的地址，&st，形参是(struct stat *statbuf)
    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 * fileGrp = 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, fileGrp, fileSize, mtime, argv[1]);

    printf("%s\n", buf);

    return 0;
}

9.1 获取文件所有者调用的函数详细内容：

man 3 getpwuid

getpwuid函数的返回类型为 struct passwd*
在这里插入图片描述
struct passwd*这个结构体长这样：
在这里插入图片描述

9.2 关于st.st_size的类型

跳转1

在这里插入图片描述

跳转2

在这里插入图片描述

跳转3

在这里插入图片描述

跳转4

在这里插入图片描述

9.3 ctime传参

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

形参是(const time_t *)，实参的类型是st_mtime，传入他的地址

关于传参的疑惑，为什么传入地址，是不是形参是*类型的都需要传入地址？

10. 文件属性操作函数

在这里插入图片描述

10.1 access.c

/*
    #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");
    }

    printf("文件存在！！!\n");

    return 0;
}

10.2 chmod.c

/*
    #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", 0777);

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

    return 0;
}

类似的chown的函数声明
在这里插入图片描述
在这里插入图片描述
查看所有用户的用户id和所在组的ID

vim /etc/passwd

查看所有组的ID

vim /etc/group

默认创建的用户的组名和用户名是一样的。

10.3 truncate.c

/*
    #include <unistd.h>
    #include <sys/types.h>
    int truncate(const char *path, off_t length);
        作用：缩减或者扩展文件的尺寸至指定的大小
        参数：
            - path: 需要修改的文件的路径
            - length: 需要最终文件变成的大小
        返回值：
            成功返回0， 失败返回-1
*/

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

int main() {

    int ret = truncate("b.txt", 5);

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

    return 0;
}

11. 目录操作函数

在这里插入图片描述

11.1 mkdir.c

/*
    #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;
}

11.2 rename.c

/*
    #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;
}

11.3 chdir.c

介绍两个Linux函数：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;
}
  1. 首先，获取当前的工作目录，应该是lesson14
  2. 然后，修改工作目录为lesson13
  3. 最后在当前已修改的路径lesson13下，创建一个chdir.txt

12. 目录遍历函数

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

12.1 readFileNum.c

/*
    // 打开一个目录
    #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>

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;

        // 忽略掉. 和..
        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;
}

13. dup、dup2函数（文件描述符复制相关操作）

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

13.1 dup.c

多个文件描述符可以指向同一个文件，fd和fd1指向同一个a.txt，使用fd1操作a.txt，和fd操作结果一样

/*
    #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_RDWR | O_CREAT, 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;
}

13.2 dup2.c

/*
    #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值相同，相当于什么都没有做
    返回值：跟新的文件描述符fd1一样的
*/
#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;
    }
	//fd2和fd1相同
    printf("fd : %d, fd1 : %d, fd2 : %d\n", fd, fd1, fd2);

    close(fd);
    close(fd1);

    return 0;
}

14. fcntl函数

在这里插入图片描述

14.1 fnctl.c

int open(const char *pathname, int flags);
参数：
- pathname：要打开的文件路径
- flags：对文件的操作权限设置还有其他的设置
O_RDONLY, O_WRONLY, O_RDWR 这三个设置是互斥的
返回值：返回一个新的文件描述符，如果调用失败，返回-1
errno：属于Linux系统函数库，库里面的一个全局变量，记录的是最近的错误号。

/*

    #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 表示追加数据
                O_NONBLOK 设置成非阻塞
        
        阻塞和非阻塞：描述的是函数调用的行为。add()返回值没有返回之前，进程被挂起，之后再返回；非阻塞的函数立马返回
        终端是阻塞的，等待我们的输入；输入之后再被执行
*/

#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
    //注意：不能使用O_RDONLY，否则即使追加也没法写入
    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这个标记
    // 注意：不能直接写O_APPEND，这样会直接覆盖原来的O_RDONLY，导致没有O_RDONLY的权限
    // 错误示范：int ret = fcntl(fd, F_SETFL, 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;
}

15. 完结撒花

Luck66Max
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
文件IO----标准IO和Linux文件IO
m0_72387416的博客
08-12 153
文件IO有两种 标准IO ： 标准C库为我们提供的函数 Linux文件IO： Linux系统自带的函数
标准IO和文件IO的区别（基于Linux操作系统）
qq_45126578的博客
04-06 4815
标准IO和文件IO的区别（基于Linux操作系统）
Linux文件IO与标准IO
qq_54924532的博客
07-28 292
文件io于标准io
Linux文件 IO 和标准 IO简介
yangxueyangxue的博客
01-12 2269
文件 IO 是 Linux 系统提供的接口， 针对文件和磁盘进行操作， 不带缓存机制； 标准 IO 是 C 语言函数库里的标准 I/O 模型， 在 stdio.h 中定义， 通过缓冲区操作文件， 带缓存机制。 Linux 系统中一切皆文件， 包括普通文件， 目录， 设备文件（不包含网络设备） ， 管道， fifio 队列， socket 套接字等， 在终端输入“ls -l”可查看文件类型和权限。
jacob-1.17-M2
07-09
jacob-1.17-M2jacob-1.17-M2jacob-1.17-M2jacob-1.17-M2jacob-1.17-M2jacob-1.17-M2jacob-1.17-M2jacob-1.17-M2jacob-1.17-M2jacob-1.17-M2jacob-1.17-M2jacob-1.17-M2jacob-1.17-M2jacob-1.17-M2jacob-1.17-M2jacob...
jacob-1.17-M2（支持64位和32位）.rar
06-05
jacob-1.17-M2（支持64位和32位），包含64位和32位，使用前操作 1、把dll文件放在%JAVA_HOME%\bin下（注意系统是32位还是64位），也可以放在C:\Windows\System32下，如果是64位应该放在C:\Windows\SysWOW64 下。...
Linux初学基本命令
yuan20010401的博客
07-25 509
1、rm 文件名称 删除多个文件多个目录需要用空格 删除根目录（rm -rf /*）1、touch 文件名字 用于linux创建文件 创建多个目录需要用空格隔开。2、mkdir 目录名称 用于创建文件夹 创建多个嵌套文件夹需要用/隔开。1、cp 当前文件 其他目录名称 拷贝文件夹需要在最后 -r。退出不保存时按Esc+:q!1、ls 查看当前目录下面的文件或者文件夹。2、more 文件名称 查看文件更多内容。1、mv 原文件路径 目标文件路径。退出保存时按Esc + :wq。
【linux】Shell脚本三剑客之awk命令的详细用法攻略
景天科技苑
07-24 4858
在Linux和Unix系统中，awk是一种强大的文本处理工具，广泛应用于数据提取、分析和报告生成。它基于模式匹配和条件执行，能够逐行读取输入文本文件，并对每行数据执行指定的操作。本教程将详细介绍`awk`在shell脚本中的用法，包括其基本语法、常用选项、内置变量、高级特性以及结合shell脚本的实际案例。
60个常见的 Linux 指令
yatingliu的博客
07-25 1202
是 “substitute user” 或 “switch user” 的缩写，它可以让你切换到另一个用户账户，包括 root 用户。是 “manual” 的缩写，通过它你可以访问系统的手册页（manual pages），这些手册页提供了详细的使用说明和参考信息。在一些 Linux 发行版中，adduser 是 useradd 的一个友好封装，功能上类似但提供了更多的默认设置和提示。-f, --force：强制删除，不提示错误信息，即使文件不存在也不会报错。：设置密码过期时间，单位为天。
【C语言】Linux 飞翔的小鸟
Minuhy
07-22 786
在Linux下运行的，用C语言编写的飞翔的小鸟，一款挺无聊的小游戏，分享给大家~
【Linux】多路转接 -- select函数
最新发布
m0_72940975的博客
07-31 1018
多路转接也叫多路复用，是一种用于管理多个IO通道的技术。它能实现同时监听和处理多个IO事件，而不是为每个IO通道创建单独的线程或者进程，多路转接允许在单个进程或线程中同时处理多个IO操作，从而提高程序的性能和效率。本篇文章介绍的select函数，就用于select系统调用的多路转接技术。select函数是系统提供的一个多路转接接口。IO = 等待就绪 + 数据拷贝，而select是只负责等。 参数说明：参数timeout的取值：返回值说明：select调用失败，错误码可能被设置为：fd_set 结构与 si
使用易备数据备份软件，践行虚拟机最佳备份方案
sanyuan7783的博客
07-26 913
新的关键业务应用程序有助于为容器和容器化工作负载赋予更大动力。但是，在可预见的未来，虚拟机的应用仍会普遍存在。容器和虚拟机可以很好地协同工作，适用于大多数关键的 IT 基础设施。因此，备份虚拟机及其包含的数据、服务和应用程序仍然是企业至关重要的任务。本文以 VMware vSphere 虚拟机为例，介绍虚拟机备份的最佳实践方法。
二进制部署k8s集群之master节点和etcd数据库集群（上）
zx52306的博客
07-30 686
【代码】二进制部署k8s集群之master节点和etcd数据库集群（上）
IT运维必备神器！PsShutdown，定时关机重启一键搞定！
weixin_39410685的博客
07-30 290
下次见，我们后会有期！当你坐在电脑前，手指轻轻敲几下键盘，就能实现定时任务，无论是关机、重启，还是注销用户，甚至是锁屏，都尽在掌握之中；别急，咱们先不聊那些冷冰冰的功能参数，来聊聊它背后的故事这个名字听起来就带着一股子神秘感，它出自Sysinternals这个大名鼎鼎的宝库，那可是微软旗下的技术大佬们的智慧结晶啊。而且哦，这款工具的使用体验简直不要太友好，不需要繁琐的安装过程，只需要简单几步，就能让它成为你电脑里的得力助手；无论你是IT界的老司机，还是刚入门的小白，都能轻松上手，享受它带来的便捷与高效；
Docker容器下面home assistant忘记账号密码怎么重置？
玩人工智能的辣条哥的博客
07-30 117
docker ha。
微软：警惕利用VMware ESXi进行身份验证绕过攻击
FreeBuf_的博客
07-30 279
到目前为止，该漏洞已被被追踪为 Storm-0506、Storm-1175、Octo Tempest 和 Manatee Tempest 的勒索软件运营商在野外利用，并在攻击中部署了Akira和Black Basta勒索软件。虽然成功实施攻击需要对目标设备和用户交互具有高权限，但微软表示，已有几个勒索软件团伙利用漏洞完全掌控了管理员权限，窃取存储在托管虚拟机上的敏感数据，在受害者的网络中横向移动，并加密 ESXi 虚拟机管理程序的文件系统。以Storm-0506为例的ESXi 攻击链。
AccessLog| 一款开源的日志分析系统
ClkLog的博客
07-26 486
系统采用Java语言、搭配OLAP数据库，涵盖基本web日志分析，同时提供性能分析，帮助高效运维
Linux 普通用户启动Nginx使用80端口，小于1024的端口
y393016244的博客
07-26 128
在root用户下执行。
vmware 设置ip
一路向前
07-30 447
上面操作都是用root身份进行操作的。一步一步操作下来，应该问题不大，注意手动配置ip那边是xshell连接的ip
jacob-1.17-m2.rar
12-20
jacob-1.17-m2.rar是一个文件名，通常表示它是一个压缩文件。文件名的开头部分“jacob-1.17”可能是指这个文件与“Jacob”软件的版本1.17有关。而“m2”可能表示这是第二个版本或者第二个修订版。而“.rar”文件后缀...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值