【linux系统编程】文件IO

最新推荐文章于 2022-04-17 17:14:07 发布
最新推荐文章于 2022-04-17 17:14:07 发布
阅读量166 收藏 1
点赞数
分类专栏： linux系统编程 文章标签： linux ubuntu linux系统编程 文件io
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zhouzi_heng/article/details/120389243
版权

一、系统调用

 二、打开/关闭文件

2.1、open函数

 （1）打开一个存在的文件

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

int main(int argc, char* argv[])
{
        int fd = open("./leetcode.txt",O_RDONLY);
        printf("fd = %d\n",fd);
        close(fd);
        return 0;
}

（2）打开一个不存在文件

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
int main(int argc, char* argv[])
{
        int fd = open("leetcode.123",O_RDONLY);
        printf("fd = %d, errno = %d:%s\n",fd,errno,strerror(errno));
        close(fd);
        return 0;
}

 （3）以写方式打开只读文件（权限问题）

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
int main(int argc, char* argv[])
{
        int fd = open("leetcode.123",O_WRONLY);
        printf("fd = %d, errno = %d:%s\n",fd,errno,strerror(errno));
        close(fd);
        return 0;
}

（4）以只写方式打开目录

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
int main(int argc, char* argv[])
{
        int fd = open("myDir",O_WRONLY);
        printf("fd = %d, errno = %d:%s\n",fd,errno,strerror(errno));
        close(fd);
        return 0;
}

三、文件描述符

 ulimit -a

 四、read、write函数

read函数

write函数

 4.1、read和write实现cp

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

int main(int argc, char* argv[])
{
        char buff[1024];
        int n = 0;
        // 以只读的方式打开argv[1]
        int fd1 = open(argv[1], O_RDONLY);
        if (fd1 == -1)
        {
                perror("open argv[1] error");
                exit(1);
        }
        // 以读写的方式打开argv[2],如果不存在，则创建，文件权限为 -rw-rw-r--
        int fd2 = open(argv[2], O_RDWR|O_CREAT|O_TRUNC, 0664);

        if (fd2 == -1)
        {
                perror("open argv[2] error");
                exit(1);
        }
        // 从fd1中读数据存到到buff中，每次读1024个，并赋值给n，如果不足1024,读多少就是多少，当读的数据为0时，读完文件
        while ((n = read(fd1, buff, 1024)) != 0)
        {
                if (n < 0)
                {
                        perror("read error");
                        exit(1);
                }
                // 将读的数据以实际大小n从buff中取出，写到fd2中
                write(fd2, buff, n);
        }


        // close
        close(fd1);
        close(fd2);

        return 0;
}

 五、错误处理函数

 六、阻塞/非阻塞

阻塞、非阻塞：  是设备文件、网络文件的属性。

产生阻塞的场景。 读设备文件。读网络文件。（读常规文件无阻塞概念。）

/dev/tty -- 终端文件。

open("/dev/tty", O_RDWR|O_NONBLOCK) --- 设置 /dev/tty 非阻塞状态。(默认为阻塞状态)

6.1、阻塞读

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

int main(int argc, char* argv[])
{
        char buff[10];
        int n = read(STDIN_FILENO, buff, 10);
        if (n < 0) {
                perror("read STDIN_FILENO");
                exit(1);
        }

        write(STDOUT_FILENO, buff, n);
        return 0;
}

 运行程序后，进入等待状态（阻塞），当有输入时，程序才会接着执行，将输入的数据读入，并输出。

6.2、非阻塞超时等待

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
#include<errno.h>
#include<fcntl.h>

#define MSG_TRY "try again\n"
#define MSG_TIMEOUT "time out\n"


int main(void)
{
        char buff[10];
        int fd, n ,i;
        // 设置非阻塞读
        fd = open("/dev/tty", O_RDONLY|O_NONBLOCK);

        if (fd < 0) {
                perror("open /dev/tty");
                exit(1);
        }
        printf("open /dev/tty ok..... %d\n", fd);

        for (int i = 0; i < 5; i++) {
                // 读入数据
                n = read(fd, buff, 10);
                // 有数据读入，跳出循环
                if (n > 0) {
                        break;
                }
                if (errno != EAGAIN) {
                        perror("read /edv/tty");
                        exit(1);
                } else {
                        // 没有数据输入，则输出提示
                        write(STDOUT_FILENO, MSG_TRY, strlen(MSG_TRY));
                        sleep(2);
                }
        }
        // i等于5时，循环5次，没有读到数据，等待超时
        if (i == 5) {
                write(STDOUT_FILENO, MSG_TIMEOUT, strlen(MSG_TIMEOUT));
        } else {
                // i != 5，即读到数据，将读到的数据输出
                write(STDOUT_FILENO, buff, n);
        }
        close(fd);
        return 0;
}

 等待超时。

有数据读入，读入数据，并输出，结束程序。

七、lseek函数

 

 文件的读写使用的是同一偏移位置。

7.1、读文件

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
#include<fcntl.h>
int main(int argc, char* argv[])
{
        int fd, n;
        char msg[] = "It's a test for lseek\n";
        char ch;
        // 以读写的方式打开文件，如果不存在，则创建，权限 -rw-rw-r-
        fd = open("lseek.txt", O_RDWR|O_CREAT, 0664);
        if (fd < 0) {
                perror("open lseek.txt error");
                exit(1);
        }
        // 向文件中写入数据，此时光标在最后
        write(fd, msg, strlen(msg));
        
        // 先注释这行
        //lseek(fd, 0, SEEK_SET);

        while ((n = read(fd, &ch, 1))) {
                if (n < 0) {
                        perror("read error");
                        exit(1);
                }   
                // 将读出的数据在标准输出显示
                write(STDOUT_FILENO, &ch, n);
        }
        close(fd);

        return 0;
}

执行后没有数据输出，因为光标在最后位置。放开注释lseek(fd, 0, SEEK_SET);

 7.2、lseek读文件大小

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
#include<fcntl.h>
int main(int argc, char* argv[])
{
        int fd = open(argv[1], O_RDWR);
        if (fd == -1) {
                perror("read error");
                exit(1);
        }

        int length = lseek(fd, 0, SEEK_END);
        printf("file size is %d\n",length);
        close(fd);
        return 0;
}

这里要注意lseek函数返回值的意义

 7.3、填充大小

将7.2中的文件从2900填充为3000，查100字节。

修改代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
#include<fcntl.h>
int main(int argc, char* argv[])
{
        int fd = open(argv[1], O_RDWR);
        if (fd == -1) {
                perror("read error");
                exit(1);
        }
        // 从文件结束位置再偏移100
        int length = lseek(fd, 100, SEEK_END);
        printf("file size is %d\n",length);
        close(fd);
        return 0;
}

下面再用ls命令查看

它的大小不是3000。

原因是，要使文件大小真正拓展，必须引起IO操作。

修改后的扩展文件代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
#include<fcntl.h>
int main(int argc, char* argv[])
{
        int fd = open(argv[1], O_RDWR);
        if (fd == -1) {
                perror("read error");
                exit(1);
        }

        int length = lseek(fd, 99, SEEK_END);
        printf("file size is %d\n",length);
        write(fd, "$", 1);
        close(fd);
        return 0;
}

 这里2999和3000是因为lseek读取到偏移差的时候，还没有写入最后的‘$’符号。

查看文件

末尾那一大堆^@，是文件空洞，如果自己写进去的也想保持队形，就写入“\0”。

7.4、补充

拓展文件直接使用truncate，简单粗暴

使用 truncate 函数，直接拓展文件。 int ret = truncate("robot.txt", 5000);

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
#include<fcntl.h>
int main(int argc, char* argv[])
{
        int length = truncate("robot.txt", 5000);
        return 0;
}

八、fcntl函数

 

这个函数超复杂，这里知识简单学习

fcntl用来改变一个【已经打开】的文件的 访问控制属性

重点掌握两个参数的使用， F_GETFL，F_SETFL

fcntl：
	int (int fd, int cmd, ...)
    fd		文件描述符
    cmd		命令，决定了后续参数个数

获取文件状态： F_GETFL

设置文件状态： F_SETFL

8.1、修改属性

终端文件默认是阻塞读的，这里用fcntl将其更改为非阻塞读

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
#include<fcntl.h>
#include<errno.h>

#define MSG_TRY "try again\n"

int main(int argc, char* argv[])
{
        char buff[10];
        int flags, n;

        flags = fcntl(STDIN_FILENO, F_GETFL);    // 获取stdin的属性信息
        if (flags == 1) {
                perror("fcntl error");
                exit(1);
        }
        // 用或位运算符修改属性
        flags |= O_NONBLOCK;
        // 再将属性赋回去，此时stdin就是非阻塞
        int ret = fcntl(STDIN_FILENO, F_SETFL, flags);
        if (ret == -1) {
                perror("fcntl error");
                exit(1);
        }

tryagain:
        n = read(STDIN_FILENO, buff, 10);
        if (n < 0) {
                // 出错
                if (errno != EAGAIN) {
                        perror("read /dev/tty");
                        exit(1);
                }
                sleep(3);
                write(STDOUT_FILENO, MSG_TRY, strlen(MSG_TRY));
                goto tryagain;
        }
        write(STDOUT_FILENO, buff, n);

        return 0;
}

可以看到，是非阻塞读取。 

StudyWinter
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux 系统函数 open,Linux系统函数open,read,write(示例代码)
weixin_39806779的博客
05-01 164
实现代码#include#include#include#include#include //perror()#include //exit()#define BUFFER_SIZE 1024int main(int argc,char *argv[]){intfrom_fd;intto_fd;unsignedintfile_len;int ret = 1;charbu...
文件描述符fd，open函数
weixin_38011893的博客
03-05 1818
1.参数fd（open函数的返回值），是要关闭的文件描述符。当一个进程终止时，内核对该进程所有尚未关闭的文件描述符调用close关闭，所以即使用户程序不调用close，在终止时内核也会自动关闭它打开的所有文件。但是，作为一个合格的程序员，还是要手动关闭，因为在程序运行时间特别长的情况下，会浪费这个fd资源。 2.由open返回的文件描述符一定是该进程尚未使用的最小描述符。
Linux系统编程--read/write
木牛的博客
06-01 982
4. read/write  read函数从打开的设备或文件中读取数据。 #include  ssize_t read(int fd, void *buf, size_t count); 返回值：成功返回读取的字节数，出错返回-1并设置errno，如果在调read之前已到达文件末尾，则这次read返回0 参数count是请求读取的字节数，读上来的数据保存在缓冲区buf中，同时文件的
Linux中的STDIN_FILENO和STDOUT_FILENO
沫俱宏
09-18 3万+
环境：Vmware Workstation；CentOS-6.4-x86_64 说明： STDIN_FILENO：接收键盘的输入 STDOUT_FILENO：向屏幕输出 程序： 接收用户在屏幕上输入的数据，并在屏幕上输出（要求使用read和wirte实现），用户输入quit就退出程序。 图解说明： 步骤： 1、创建并编写源文件main.c： #include
一个write和printf混用的例子
Carrot_kexin的博客
10-15 525
我们知道，C语言中，write和printf都可以完成向屏幕输出的任务。 但是write是不带缓冲的输出，printf是带缓冲的输出。当它们二者混用时，就会出现一些意料之外的问题。 请看下面的代码 #include <stdio.h> #include <unistd.h> int main(){ printf("1"); write(STDOUT_FILENO, "2", 1); printf("3"); write(STDOUT_FILENO,
01--Linux系统编程-文件IO.pdf
10-08
linux 开发者，学习c ,c++
Linux操作系统编程教学pdf
01-10
"2.3 Linux文件的IO操作1.pdf"是关于Linux文件输入输出（I/O）操作的介绍，这是任何编程语言在Linux环境下都需要掌握的基础技能。内容可能涵盖open、read、write、close等系统调用，以及文件描述符、缓冲区管理和非...
Linux 文件IO编程-模拟登陆系统
08-26
本项目"Linux 文件IO编程-模拟登陆系统"旨在通过实践，让开发者深入理解如何利用C语言进行文件操作，并结合Linux图形库curses实现一个简单的用户交互界面。下面将详细介绍这个项目涉及的关键知识点。 1. 文件IO编程...
Linux系统编程--文件IO1
08-08
《TCP/IP 详解》(3卷)，《UNIX网络编程》（2卷）参考书2：《Linux系统编程》RobertLoVe [美] 参考书3：《Linux/UNIX系统编
Linux系统和网络编程学习文件
最新发布
11-16
这个名为"Linux系统和网络编程学习文件"的压缩包很可能是为了帮助学习者掌握这些核心技能。以下是对其中涉及知识点的详细说明： 1. **Linux系统基础**： - **文件系统**：Linux使用的是类Unix的文件系统结构，了解...
linux文件系统及写延迟
Peach2Orange的博客
01-05 5194
一、文件同步  write不能满足要求，需要fsync        Linux、unix在内核中设有缓冲区、高速缓冲或页面高速缓冲，大多数磁盘I/O都通过缓冲进行，采用延迟写技术。      对于write函数，我们认为该函数一旦返回，数据便已经写到了文件中。但是这种概念只是宏观上的，一般情况下，对硬盘（或者其他持久存储设备）文件的write操作，更新的只是内存中的页缓存（page cac
stdin、stdout、stderr和STDIN_FILENO、STDOUT_FILENO、STDERR_FILENO的区别和联系
linkvivi的博客
05-19 4002
转载自：https://blog.csdn.net/yeyuangen/article/details/67819991、STDIN_FILENO的作用：    ①STDIN_FILENO属于系统API接口库，其声明为 int 型，是一个打开文件句柄，对应的函数主要包括 open/read/write/close 等系统级调用。        ②操作系统一级提供的文件API都是以文件描述符来表示文...
文件与IO
u011616934的博客
02-05 597
文件与IO
Linux进程控制
抚琴弹出情凋零的博客
04-17 1250
1.pipe管道通信 int pipe (int __pipedes[2]); pipefd读写文件描述符，0：代表读， 1：代表写 返回值：失败返回-1，成功返回0 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #..
TCP/IP，网络编程中的任何函数在调用时都需要检查返回值的简化做法，使用nc命令模拟客户端，向STDOUT_FILENO文件写入信息相当于打印到屏幕，vim中使用shift+k查看函数文档
ganfanren00001的博客
04-03 1838
TCP/IP，网络编程中的任何函数在调用时都需要检查返回值的简化做法，使用nc命令模拟客户端，向STDOUT_FILENO文件写入信息相当于打印到屏幕，vim中使用shift+k查看函数文档 一、socket编程中的每一个函数在调用过后，为了保持代码健壮性，都需要在后面加上if判断执行结果，导致代码打乱逻辑，可以封装原有函数，将判断过程封装起来，调用封装以后的函数，使代码看上去条理清晰。 代码案例： int Bind(int sockfd, const struct sockaddr *addr, sock
嵌入式操作系统网络编程（4）
Sunlightljj的博客
03-14 254
四、dup、dup2 (https://blog.csdn.net/silent123go/article/details/71108501) 1、文件描述符在内核中数据结构 在具体说dup/dup2之前，我认为有必要先了解一下文件描述符在内核中的形态。一个进程在此存在期间，会有一些文件被打开，从而会返回一些文件描述符，从shell中运行一个进程，默认会有3个文件描述符存在(0、１、2)，0与进程...
Linux网络编程(2)
PT的博客
03-30 386
1、客户端程序 #include<stdio.h> #include<unistd.h> #include<stdlib.h> #include<sys/socket.h> #include<arpa/inet.h> #include<string.h> #define SERV_IP "127.0.0.1" #defin...
read（）函数简介
热门推荐
zjhkobe的专栏
07-26 4万+
read函数从打开的设备或文件中读取数据。#include ssize_t read(int fd, void *buf, size_t count); 返回值：成功返回读取的字节数，出错返回-1并设置errno，如果在调read之前已到达文件末尾，则这次read返回0
系统编程 笔记2
aavv787878的博客
05-10 205
1.库函数和系统函数的对比（得在一定条件下，得在系统函数那个程序把buf设置成1，如果设置成4096那么两个程序的速度是一样的） 使用库函数虽然看似比直接使用系统调用多了一步，但是从用户空间进入内核空间耗时巨大，在对比库函数和系统函数的copy.c中，系统函数buf被设置成1时，程序每读取一个字节就得完成一次内核空间和用户空间的跳转，而库函数（fputc函数），在函数内部有一个buf而这个buf默认是4096，也就是内核空间的缓冲向磁盘写入所需要的值（每当内核空间缓冲满4096，就向磁盘写入数据），所以可以
Linux系统编程：文件IO与进程通信详解
"该资源是关于Linux系统编程的教程，主要涵盖了C语言在Linux环境下的应用，包括文件I/O、文件系统、进程管理和进程间通信等多个核心主题。内容详细，适合学习者深入理解Linux底层机制和系统编程技能。" 详细说明： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值