当前位置：首页 > news >正文

Linux (open、write、read、close、lseek、chmod、sync)操作文件的函数详解

news 来源：原创 2023/3/27 22:38:32

一、文件操作方式

二、Linux底层文件操作

1. open

2. write

3. read

4. close

5. lseek

6. chmod

7. sync、syncfs、fsync、fdatasync

三、 Linux 系统调用

四、总结

linux中，一切皆文件（网络设备除外）

硬件设备也“是”文件，通过文件来使用设备

目录（文件夹）也是一种文件

这篇文章将记录open、write、read、close、lseek等Linux系统函数的用法。

补充：time 命令

time命令分别输出:

real - 程序总的执行时间；

usr - 该程序本身所消耗的时间；

sys - 系统调用所消耗的时间.

例：

一、文件操作方式

1. 文件描述符 fd

是一个 >= 0 的整数

每打开一个文件，就创建一个文件描述符，通过文件描述符来操作文件

多次打开同一个文件，可得到多个不同的文件描述符。

预定义的文件描述符：(具体请看下面课外补充)

0：标准输入(stdin)，对应于已打开的标准输入设备（键盘）

1：标准输出(stdout)，对应于已打开的标准输出设备（控制台）

2：标准错误(stderr)，对应于已打开的标准错误输出设备（控制台）

这里可以使用write在控制台输出信息，跟printf性质一样，例：

#include <unistd.h>
#include <stdio.h>
#include <string.h>int main(void) {char buf[1024];memset(buf, 0, sizeof(buf));read(0, buf, sizeof(buf));     // 标准输入printf("%s", buf);             // 输出到控制台write(1, buf, sizeof(buf));    // 标准输出到控制台write(2, buf, sizeof(buf));    // 标准错误输出到控制台return 0;
}

运行结果：

ygt@YGT:~/echo_server/test$ gcc demo1.c -o demo1
ygt@YGT:~/echo_server/test$ ./demo1
使用read输入。。。。
使用read输入。。。。
使用read输入。。。。
使用read输入。。。。
ygt@YGT:~/echo_server/test$

第一条信息是我们手动输入的，因为程序运行后，read函数通过 0 这个文件描述符，在等待我们输入；

第二条输出信息是printf函数输出的；

第三条输出信息是write函数通过 1 这个文件描述符输出的；

第四条输出信息是write函数通过 2 这个文件描述符输出的。

1 和 2 都是一样输出到控制台，就他们的性质不一样而已。

2. 使用底层文件操作（系统调用）

比如：read、write

可使用man 2 查看

（将在下面进行讲解）

3. 使用I/O库函数

比如：fread

可使用man 3 查看

（就是C语言的文件操作函数，这里不进行讲解）

课外补充：

我们运行以下程序：

#include <unistd.h>int main(void) {char buf[1024] = "0, 1, 2 到底是个什么？\n";while (1) {write(1, buf, sizeof(buf));sleep(1);}return 0;
}

编译运行：

可以看到，其每一秒都会向控制台输出一段字符串。

接下来我们重写打开一个终端，在终端运行以下命令查看demo3程序的进程号：

ps -ef | grep demo3 注意：demo3是上面运行的程序名字

可以看到，./demo3的程序的进程号是 6893.

然后执行以下命令：

ll /proc/6893/fd/

我们通过查看对应程序进程号里的fd文件夹，就可以看出，Linux系统已经给./demo3这个程序默认创建了三个fd，分别是0，1，2；他们分别对应也就是标准输入，标准输出，标准出错；

所以这也就是为什么我们可以使用 write 和 read 函数和 0，1，2 进行输入和输出的操作了。

注意：

/proc/6898/ 这个文件夹是Linux系统为程序./demo3临时创建的文件夹，当这个程序结束，Linux也会随之将他们删除掉。

任何程序已启动Linux系统都会为他们创建一个属于他们自己的对应进程号的文件夹，这个进程号是随机的，文件夹的名字是对应进程号的。

例：

将./demo3这个程序退出后，再次运行命令：ll /proc/6893/fd/

二、Linux底层文件操作

1. open

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

int open (const char *pathname, int flags);
int open (const char *pathname, int flags, mode_t mode);

描述：打开指定路径的文件，返回一个文件描述符。

pathname

文件路径名；

flags

打开文件的方式；

mode

设置文件的权限；

返回值

成功：返回新的文件描述符；

失败：-1，并且设置错误编号 errno ，可用( strerror(errno) ) 查看；

注意：

返回的文件描述符是该进程未打开的最小的文件描述符；

(1) 描述

在Linux中，使用命令：man 2 open

(2) 打开方式

O_RDONLY    只读O_WRONLY    只写O_RDWR      读写O_CREAT     如果文件不存在，则创建该文件，并使用第3个参数设置权限,如果文件存在 ，则只打开文件;O_EXCL      如果同时使用O_CREAT而且该文件又已经存在时，则返回错误, 用途：以防止多个进程同时创建同一个文件;O_APPEND    尾部追加方式（打开后，文件指针指向文件的末尾）;O_TRUNC     若文件存在，则长度被截为0，属性不变.

例: open("/dev/hello", O_RDONLY|O_CREAT|O_EXCL, 0777)

多个设置可用 “|” 进行分割。

(3) 参数3 (设置权限）

当参数2使用了O_CREAT时，就得使用参数3

S_I(R/W/X)(USR/GRP/OTH)

S_IRWXU  00700  用户拥有 读 写 执行 权限S_IRUSR  00400  用户拥有 读 权限S_IWUSR  00200  用户拥有 写 权限S_IXUSR  00100  用户拥有 执行 权限S_IRWXG  00070  同组拥有 读 写 执行 权限S_IRGRP  00040  同组拥有 读 权限S_IWGRP  00020  同组拥有 写 权限S_IXGRP  00010  同组拥有 执行 权限S_IRWXO  00007  其他人拥有 读 写 执行 权限S_IROTH  00004  其他人拥有 读 权限S_IWOTH  00002  其他人拥有 写 权限S_IXOTH  00001  其他人拥有 执行 权限

可以发现，读写执行权限，是由读 + 写 + 执行而得来的；

例如用户的 00700，是由 00400 + 00200 + 00100 而得来的。

例：

S_IRUSR | S_IWUSR 文件的所有者对该文件可读可写

(八进制表示法)00600 文件的所有者对该文件可读可写

多个设置可用 “|” 进行分割。

代码示例：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>int main(void) {int fd = 0;char fileName[] = "test.txt";// 读写，如果文件不存在则创建，如果文件存在则报错(O_EXCL)；// 设置本用户拥有读写执行权限，同组用户拥有读写权限，其他人拥有读权限// fd = open(fileName, O_RDWR|O_CREAT|O_EXCL, 00764); // 可以使用数字代替参数三fd = open(fileName, O_RDWR|O_CREAT|O_EXCL, S_IRWXU|S_IRGRP|S_IWGRP|S_IROTH);if (-1 == fd) {fprintf(stderr, "open %s fail. reason: %s\n", fileName, strerror(errno));exit(-1);}printf("open %s successful!\n", fileName);// 关闭文件close(fd);return 0;
}

运行结果：

ygt@YGT:~/echo_server/test$ gcc open.c -o open
ygt@YGT:~/echo_server/test$ ./open
open test.txt successful!ygt@YGT:~/echo_server/test$ ll
-rwxrwxr-x 1 ygt  ygt  8945 11月 10 16:02 open*
-rw-rw-r-- 1 ygt  ygt   554 11月 10 16:02 open.c
-rwxrw-r-- 1 ygt  ygt     0 11月 10 16:02 test.txt*

可以看出文件已正确运行！且test.txt的权限也是正确设置的 -rwxrw-r--.

test.txt 文件已经存在，当我们再一次运行 ./open 会怎么样呢？

出现报错了，报错提示“File exists”，文件已经存在了。

因为我们设置了O_EXCL，当文件存在时，他会进行报错处理！

2. write

#include <unistd.h>

ssize_t write (int fd, const void *buf, size_t count);

描述：write()从指向buf的缓冲区向文件描述符fd引用的文件写入count个字节。

fd:

文件描述符；

buf:

需要写入的数据；

count：

指定最多写入的大小;

返回值：

成功：返回写入的字节数；

失败：返回 -1，并且设置错误编号 errno ，可用( strerror(errno) ) 查看.

描述

在Linux中，使用命令：man 2 write

注意：是从文件的当前指针位置写入！文件刚打开时，文件的位置指针指向文件头.

代码示例：

#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>#define W_LEN   1024int main(void) {int ret = 0;int fd = -1;char fileName[] = "test.txt";char buf[W_LEN] = "这是要写入的内容：Hello write！";// 打开以文件，只写方式打开，不懂00764是什么意思上面open介绍fd = open(fileName, O_WRONLY|O_CREAT|O_EXCL, 00764);if (-1 == fd) {fprintf(stderr, "open %s fail. reason: %s\n", fileName, strerror(errno));exit(-1);}// 往文件中写入数据ret = write(fd, buf, strlen(buf));if(-1 == ret) {fprintf(stderr, "write error. reason: %s\n", strerror(errno));exit(-2);}printf("write successful! write lenght: %d\n", ret);close(fd);return 0;
}

运行结果：

ygt@YGT:~/echo_server/test$ gcc write.c -o write
ygt@YGT:~/echo_server/test$ ./write
write successful! write lenght: 41
ygt@YGT:~/echo_server/test$
ygt@YGT:~/echo_server/test$ cat test.txt
这是要写入的内容：Hello write！ygt @YGT:~/echo_server/test$
ygt@YGT:~/echo_server/test$

3. read

#include <unistd.h>

ssize_t read (int fd, void *buf, size_t count);

描述：read()尝试从文件描述符fd上读取数据放入buf中，读count字节。

fd:

文件描述符；

buf:

存储读取到的数据，一般传char *类型或字符数组；

count：

指定最多读取的大小；表示最多能接受的字节数，而不是指一定要读取的字节数；

返回值：

成功：返回读取到的字节数；如果返回 0，表示文件读完了；

失败：返回 -1，并且设置错误编号 errno ，可用( strerror(errno) ) 查看.

描述

在Linux中，使用命令：man 2 read

注意：是从文件的当前指针位置读取！文件刚打开时，文件的位置指针指向文件头.

代码示例：

#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>#define R_LEN   1024int main(void) {int ret = 0;int fd = -1;char fileName[] = "test.txt";char buf[R_LEN] = { '\0' };// 打开以文件，只读方式打开，不懂00764是什么意思上面open介绍fd = open(fileName, O_RDONLY, 00764);if (-1 == fd) {fprintf(stderr, "open %s fail. reason: %s\n", fileName, strerror(errno));exit(-1);}// 从文件中读取数据ret = read(fd, buf, sizeof(buf));if(-1 == ret) {fprintf(stderr, "read error. reason: %s\n", strerror(errno));exit(-2);}printf("read successful! read lenght: %d\n", ret);printf("%s\n", buf);//write(1, buf, strlen(buf));close(fd);return 0;
}

运行结果：

ygt@YGT:~/echo_server/test$ gcc read.c -o read
ygt@YGT:~/echo_server/test$ ./read
read successful! read lenght: 41
这是要写入的内容：Hello write！
ygt@YGT:~/echo_server/test$

4. close

#include <unistd.h>

int close (int fd);

描述：close()关闭一个文件描述符，这样它就不再引用任何文件，可以被重用。

fd:

文件描述符；

返回值：

成功：返回 0；

失败：返回 -1，并且设置错误编号 errno ，可用( strerror(errno) ) 查看.

描述

在Linux中，使用命令：man 2 close

终止指定文件描述符与对应文件之间的关联，并释放该文件描述符，即该文件描述符可被重新使用.

当出现错误后，错误形式有三种：

(1). EBADF fd不是有效的打开文件描述符;

(2). EINTR close()调用被一个信号打断;

(3). EIO I/O错误.

代码示例：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>int main(void) {int ret = -1;int fd = 0;char fileName[] = "test.txt";fd = open(fileName, O_RDWR|O_CREAT, 00764);if (-1 == fd) {fprintf(stderr, "open %s fail. reason: %s\n", fileName, strerror(errno));exit(-1);}printf("open %s successful!\n", fileName);// 关闭文件ret = close(fd);if (-1 == ret) {int err = errno;fprintf(stderr, "close error. reason: %s\n", strerror(err));// 错误原因if (EBADF == err) {printf("fd不是有效的打开文件描述符\n");} else if (EINTR == err) {printf("close()调用被一个信号打断\n");} else if (EIO == err) {printf("I/O错误\n");}exit(-2);}printf("close fd successful!\n");return 0;
}

运行结果：

ygt@YGT:~/echo_server/test$ gcc close.c -o close
ygt@YGT:~/echo_server/test$ ./close
open test.txt successful!
close fd successful!
ygt@YGT:~/echo_server/test$

我们模拟将错误的文件描述符传参给close函数：

在 ret = close(fd); 这行代码前面加上：fd = -1;

然后再运行程序运行结果如下：

达到我们的预期！

注意：

如果在日常的demo中close()之后程序就结束了，那么也就无需对close的返回进行判断了，因为程序结束后，系统会回收所有资源；但是如果是在大型项目中，close之后还有很多其他操作，且文件fd的开销很大时，得进行返回值的判断，否则有可能会造成不必要的资源浪费。例如报错是EINTR，我们可以再一次调用close进行关闭fd！

5. lseek

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

off_t lseek (int fd, off_t offset, int whence);

描述：移动文件光标偏移。

fd:

文件描述符；

offset:

文件指针(光标)移动的大小；往文件头部移动设负数，往文件尾部移动设正数；

whence:

文件指针(光标)移动的依据；

返回值：

成功：返回移动后文件指针的所在位置；

失败：返回 -1，并且设置错误编号 errno ，可用( strerror(errno) ) 查看.

描述

在Linux中，使用命令：man 2 lseek

移动文件光标指针在文件的位置，方便read和write操作！

文件指针移动的依据：

SEEK_SET 相对于文件头部开始偏移；

例：移动文件指针(光标)到第100个位置处

sleek(fd, 100, SEEK_SET); // 直接从开头位置往文件尾部移动100即可

SEEK_CUR 从当前位置开始偏移；

例：文件指针已经再100位置了，现在把他移动到80的位置

sleek(fd, -20, SEEK_CUR); // 在文件指针当前位置往文件头部移动-20个位置即可

SEEK_END 相对于文件尾部开始偏移；

例：文件指针已经再80位置了，现在把他移动到倒数第5个位置

sleek(fd, -5, SEEK_END); // 直接在文件尾部往文件头部移动-5个位置即可

代码示例：

需求，移动文件光标到100的位置，然后读取100个字节打印输出。

#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>#define R_LEN           1024
#define READ_LEN        100int main(void) {int ret = 0;int fd = -1;char fileName[] = "lseek.c";char buf[R_LEN] = { '\0' };fd = open(fileName, O_RDONLY);if (-1 == fd) {fprintf(stderr, "open %s fail. reason: %s\n", fileName, strerror(errno));exit(-1);}// 从文件头部往文件尾部移动100位置ret = lseek(fd, 100, SEEK_SET);if (-1 == ret) {fprintf(stderr, "lseek error. reason: %s\n", strerror(errno));exit(-2);}// 从文件中读取100个字节ret = read(fd, buf, READ_LEN);if(-1 == ret) {fprintf(stderr, "read error. reason: %s\n", strerror(errno));exit(-3);}printf("read successful! read lenght: %d\n", ret);printf("%s\n", buf);//write(1, buf, strlen(buf));close(fd);return 0;
}

运行结果：

可以通过SEEK_END来获取文件大小：

int fileSize = lseek(fd, 0, SEEK_END);

6. chmod

#include <sys/stat.h>

int chmod (const char *path, mode_t mode);
int fchmod (int fd, mode_t mode);

描述：修改文件的权限。

fd:

文件描述符；

path

文件路径名；

mode

修改的文件的权限；

返回值

成功：返回 0

失败：-1，并且设置错误编号 errno ，可用( strerror(errno) ) 查看

(1) 描述

在Linux中，使用命令：man 2 chmod

当文件已打开，那么使用fchmod函数，如果文件没打开，那么使用chmod函数。

(2) 参数二 mode (修改的权限）

S_I(R/W/X)(USR/GRP/OTH)

S_IRWXU  00700  用户拥有 读 写 执行 权限S_IRUSR  00400  用户拥有 读 权限S_IWUSR  00200  用户拥有 写 权限S_IXUSR  00100  用户拥有 执行 权限S_IRWXG  00070  同组拥有 读 写 执行 权限S_IRGRP  00040  同组拥有 读 权限S_IWGRP  00020  同组拥有 写 权限S_IXGRP  00010  同组拥有 执行 权限S_IRWXO  00007  其他人拥有 读 写 执行 权限S_IROTH  00004  其他人拥有 读 权限S_IWOTH  00002  其他人拥有 写 权限S_IXOTH  00001  其他人拥有 执行 权限

可以发现，读写执行权限，是由读 + 写 + 执行而得来的；

例如用户的 00700，是由 00400 + 00200 + 00100 而得来的。

例：

S_IRUSR | S_IWUSR 文件的所有者对该文件可读可写

(八进制表示法)00600 文件的所有者对该文件可读可写

多个设置可用 “|” 进行分割。

例：

新建文件 test.txt, 查看其权限：

touch test.txt

可以看到，默认的权限是 读写|读|读；

即本用户有读写权限，同组其他用户有读的权限；其他组用户有读的权限。

fchmod：将test.txt文件的权限修改为执行|执行|执行

#include <stdio.h>
#include <sys/types.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/stat.h>int main(void) {int ret = 0;int fd = 0;char fileName[1024] = "test.txt";//fd = open(fileName, O_RDWR|O_CREAT|O_EXCL, S_IRWXU|S_IRGRP|S_IWGRP|S_IROTH);fd = open(fileName, O_RDWR, 00764); // 权限：读写执行|读写|读if (-1 == fd) {fprintf(stderr, "open %s fail. reason: %s\n", fileName, strerror(errno));exit(-1);}// 修改文件权限//ret = fchmod(fd, S_IXUSR|S_IXGRP|S_IXOTH);ret = fchmod(fd, 00111);    // 修改权限为：执行|执行|执行if (-1 == ret) {fprintf(stderr, "fchmod %s fail. reason: %s\n", fileName, strerror(errno));exit(-2);}printf("fchmod successful!\n");close(fd);return 0;
}

运行结果：

root@YGT:/home/ygt/echo_server/test# gcc fchmod.c -o fchmod
root@YGT:/home/ygt/echo_server/test# ./fchmod
fchmod successful!
root@YGT:/home/ygt/echo_server/test#
root@YGT:/home/ygt/echo_server/test# ll
---x--x--x 1 root root    0 11月 16 12:04 test.txt*
root@YGT:/home/ygt/echo_server/test#

可以看到，test.txt文件的权限已经被修改为 执行|执行|执行 了，即用户只有执行权限，同组的用户也只有执行权限，其他组的用户也只有执行权限。

chmod：将test.txt文件的权限修改为读|读|读

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/stat.h>   // chmodint main(void) {int ret = 0;// 修改文件权限//ret = chmod("test.txt", S_IRUSR|S_IRGRP|S_IROTH);ret = chmod("test.txt", 00444);     // 修改权限为：读|读|读if (-1 == ret) {fprintf(stderr, "fchmod %s fail. reason: %s\n", "test.txt", strerror(errno));exit(-1);}printf("fchmod successful!\n");return 0;
}

运行结果：

root@YGT:/home/ygt/echo_server/test# gcc chmod.c -o chmod
root@YGT:/home/ygt/echo_server/test# ./chmod
fchmod successful!
root@YGT:/home/ygt/echo_server/test#
root@YGT:/home/ygt/echo_server/test# ll
-r--r--r-- 1 root root    0 11月 16 12:04 test.txt
root@YGT:/home/ygt/echo_server/test#

可以看到，test.txt文件的权限已经被修改为 读|读|读 了，即用户只有读权限，同组的用户也只有读权限，其他组的用户也只有读权限。

7. sync、syncfs、fsync、fdatasync

Linux同步机制。

简单来讲，使用上面介绍的write后，或者做其他对文件有修改的操作后，需要进行同步，将数据从内核缓冲区写入磁盘；否则如果断电或系统宕机，即使已经调用了write或fwrite函数，数据都还没有写入磁盘。

#include <unistd.h>

1. sync

void sync(void);

描述：将所有修改过的块缓冲区排入写队列，然后就返回，它并不等待实际写磁盘操作结束！ sync不会执行失败！

2. syncfs

int syncfs(int fd);

描述：syncfs()类似于sync()，但只同步包含由打开的文件描述符fd引用的文件的文件系统。

fd:

文件描述符；

返回值：

成功：返回 0；

失败：返回 -1，并且设置错误编号 errno ，可用( strerror(errno) ) 查看.

3. fsync

int fsync(int fd); // 推荐使用！

描述：fsync()将文件描述符fd引用的文件(即修改的缓冲区缓存页)的所有修改的内核数据传输(“刷新”)到磁盘设备(或其他永久存储设备)，以便即使在系统崩溃或重新启动后也可以检索所有更改的信息。这包括写入磁盘缓存或刷新磁盘缓存(如果存在的话)。他会一直阻塞，直到执行完毕！

fd:

文件描述符；

返回值：

成功：返回 0；

失败：返回 -1，并且设置错误编号 errno ，可用( strerror(errno) ) 查看.

4. fdatasync

int fdatasync(int fd);

描述：fdatasync()类似于fsync()，但它只影响文件的数据部分。而除数据外，fsync还会同步更新文件的属性。

fd:

文件描述符；

返回值：

成功：返回 0；

失败：返回 -1，并且设置错误编号 errno ，可用( strerror(errno) ) 查看.

使用案例一：C语言 I/O

FILE *fp = NULL;
fp = fopen(filename,"rw" );// 函数int fileno(FILE*stream) 把文件流描述符（fp）转换为文件描述符（fd）
int fd = fileno(fp);char buff[64] = "hello world";
fwrite(buff, sizeof(buff), 1, fp);fflush(fp);
fsync(fd);
fclose(fp);

使用案例二：Linux系统调用

int fd = open(filename, O_RDWR);
char buff[64] = "hello world";write(fd, buff，sizeof(buff));fsync(fd);
close(fd);

三、 Linux 系统调用

根据我个人的理解，系统调用就是调用Linux内核中的函数。

Linux系统中分为 用户空间 和 内核空间；

用户空间是我们程序运行所在的空间；

例如，我们的程序中有个open函数，open函数内部会调用函数syscall函数，这个函数就会调用系统内部的sys_open函数，进入内核空间进行相应操作，然后再将相应返回值进行返回；

每执行一次上面介绍的open、write、read等函数，就是再执行一次系统调用！

为什么要有系统调用？

1. 举个例子，我们所用的硬盘有很多品牌，但每个品牌所用的读取写入参数接口函数可能都是不一样的(硬件编码)，将用户与底层分离开来，用户只需调用read、write等函数即可对所有类型的硬盘做操作；

2. 为了安全性。分为用户空间和内核空间，用户没法直接对内核空间做操作，确保系统的安全性；

3. 可移植性。不同平台，不同硬件，不同Linux系统他们的内核都差不多，都会有open、write等函数。

系统调用两个关键要素：

1. 系统调用号

每个系统调用被赋予一个系统调用号，与具体的系统调用相关联。

2. 系统调用表

内核维护系统调用表，保存系统调用函数的起始地址，系统调用号对应系统调用在调用表中的偏移量。

系统调用会影响效率嘛？

会！频繁使用底层系统调用会影响程序的执行效率。

因为频繁的从用户空间去到内核空间去访问，然后再返回到用户空间去继续执行，会有消耗。

例：

两个程序：写一个1G的文件，定义数组buf，大小为2048和16，循环每次往数组写入2048和16字节大小，比较两次所耗费的时间。

#define W_LEN 16
#define W_LEN 2048

循环次数：

一个程序写入次数：（1024*1024*1000） / 16 == 65,536,000 次

一个程序写入次数：（1024*1024*1000） / 2048 == 512,000 次


#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>//#define W_LEN           16
#define W_LEN           2048
#define FILE_SIZE       (1024*1024*1000)int main(void) {int ret = 0;int fd = -1;char fileName[] = "test.txt";char buf[W_LEN];// 打开以文件，只写方式打开，不懂00764是什么意思上面open介绍fd = open(fileName, O_WRONLY|O_CREAT|O_EXCL, 00764);if (-1 == fd) {fprintf(stderr, "open %s fail. reason: %s\n", fileName, strerror(errno));exit(-1);}memset(buf, '6', sizeof(buf));int count = FILE_SIZE / sizeof(buf);    // 次数int i = 0;for (; i < count; i++) {// 往文件中写入数据ret = write(fd, buf, strlen(buf));if(-1 == ret) {fprintf(stderr, "write error. reason: %s\n", strerror(errno));exit(-2);}}printf("write successful!\n");close(fd);return 0;
}

运行程序，通过上面所介绍的，使用time参数去显示程序运行所耗费的时间：

gcc systemCall_2048.c -o systemCall_2048      // #define W_LEN    2048gcc systemCall_2048.c -o systemCall_16        // #define W_LEN    16

可以看出，系统调用执行的次数越多，所耗费的时间就越长；所以，以此证明，多次执行系统调用是会耗费资源的。

那如何解决这样的问题呢？

尽可能少调用系统接口，能一次搞定的避免多次！
另外，网上说，如果多调用GLIBC库和 GLIB库！

反正不会的话，就直接用C语言的 I/O 文件操作函数即可，即fopen、fwrite、fread等这类函数！

四、总结

Linux操作文件的函数已经介绍完毕。

我们学会的同时也要注意系统调用带来的后果，只要有了这方面的意识，在写C/C++代码时，就会注意到，就不会写出效率慢的代码。

查看全文中文繁体

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.exyb.cn/news/show-4499272.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈，一经查实，立即删除！