《I.MX6U嵌入式Linux C应用编程指南 V1.1》第二章 文件I/O基础

正点原子运营

1）实验平台：正点原子阿尔法Linux开发板
2)  章节摘自【正点原子】《I.MX6U嵌入式Linux C应用编程指南 V1.1》
3）购买链接:https://detail.tmall.com/item.htm?id=609033604451
4）全套实验源码+手册+视频下载地址：http://www.openedv.com/docs/boards/arm-linux/zdyz-i.mx6ull.html
5）正点原子官方B站：https://space.bilibili.com/394620890
6）正点原子阿尔法Linux交流群：1027879335

第二章 文件I/O基础

本章给大家介绍Linux应用编程中最基础的知识，即文件I/O（Input、Outout），文件I/O指的是对文件的输入/输出操作，说白了就是对文件的读写操作；Linux下一切皆文件，文件作为Linux系统设计思想的核心理念，在Linux系统下显得尤为重要，所以对文件的I/O操作既是基础也是最重要的部分。
本章将向大家介绍Linux系统下文件描述符的概念，随后会逐一讲解构成通用I/O模型的系统调用，譬如打开文件、关闭文件、从文件中读取数据和向文件中写入数据以及这些系统调用涉及的参数等内容。
本章将会讨论如下主题内容。
1.文件描述符的概念；
2.打开文件open()、关闭文件close()；
3.写文件write()、读文件read()；
4.文件读写位置偏移量。

2.1一个简单的文件IO示例
本章主要介绍文件IO操作相关系统调用，一个通用的IO模型通常包括打开文件、读写文件、关闭文件这些基本操作，主要涉及到4个函数：open()、read()、write()以及close()，我们先来看一个简单地文件读写示例，应用程序代码如下所示：
示例代码 2.1.1 一个简单地文件IO示例

1. #include <sys/types.h>
   
2. #include <sys/stat.h>
   
3. #include <fcntl.h>
   
4. #include <unistd.h>
   
5. 
   
6. int main(void)
   
7. {
   
8.     char buff[1024];
   
9.     int fd1, fd2;
   
10.     int ret;
    
11. 
    
12.     /* 打开源文件src_file(只读方式) */
    
13.     fd1 = open("./src_file", O_RDONLY);
    
14.     if (-1 == fd1)
    
15.         return fd1;
    
16. 
    
17.     /* 打开目标文件dest_file(只写方式) */
    
18.     fd2 = open("./dest_file", O_WRONLY);
    
19.     if (-1 == fd2) {
    
20.         ret = fd2;
    
21.         goto out1;
    
22.     }
    
23. 
    
24.     /* 读取源文件1KB数据到buff中 */
    
25.     ret = read(fd1, buff, sizeof(buff));
    
26.     if (-1 == ret)
    
27.         goto out2;
    
28. 
    
29.     /* 将buff中的数据写入目标文件 */
    
30.     ret = write(fd2, buff, sizeof(buff));
    
31.     if (-1 == ret)
    
32.         goto out2;
    
33. 
    
34.     ret = 0;
    
35. 
    
36. out2:
    
37.     /* 关闭目标文件 */
    
38.     close(fd2);
    
39. 
    
40. out1:
    
41.     /* 关闭源文件 */
    
42.     close(fd1);
    
43.     return ret;
    
44. }

复制代码

这段代码非常简单明了，代码所要实现的功能在注释当中已经描述得很清楚了，从源文件src_file中读取1KB数据，然后将其写入到目标文件dest_file中（这里假设当前目录下这两个文件都是存在的）；在进行读写操作之前，首先调用open函数将源文件和目标文件打开，成功打开之后再调用read函数从源文件中读取1KB数据，然后再调用write函数将这1KB数据写入到目标文件中，至此，文件读写操作就完成了，读写操作完成之后，最后调用close函数关闭源文件和目标文件。
接下来我们给大家详细介绍这些函数以及相关的内容。
2.2文件描述符
调用open函数会有一个返回值，譬如示例代码 2.1.1中的fd1和fd2，这是一个int类型的数据，在open函数执行成功的情况下，会返回一个非负整数，该返回值就是一个文件描述符（file descriptor），这说明文件描述符是一个非负整数；对于Linux内核而言，所有打开的文件都会通过文件描述符进行索引。
当调用open函数打开一个现有文件或创建一个新文件时，内核会向进程返回一个文件描述符，用于指代被打开的文件，所有执行IO操作的系统调用都是通过文件描述符来索引到对应的文件，譬如示例代码 2.1.1中，当调用read/write函数进行文件读写时，会将文件描述符传送给read/write函数，所以在代码中，fb1就是源文件src_file被打开时所对应的文件描述符，而fd2则是目标文件dest_file被打开时所对应的文件描述符。
一个进程可以打开多个文件，但是在Linux系统中，一个进程可以打开的文件数是有限制，并不是可以无限制打开很多的文件，大家想一想便可以知道，打开的文件是需要占用内存资源的，文件越大、打开的文件越多那占用的内存就越多，必然会对整个系统造成很大的影响，如果超过进程可打开的最大文件数限制，内核将会发送警告信号给对应的进程，然后结束进程；在Linux系统下，我们可以通过ulimit命令来查看进程可打开的最大文件数，用法如下所示：

1. ulimit -n

复制代码

图 2.2.1 查看进程可打开的最大文件数

该最大值默认情况下是1024，也就意味着一个进程最多可以打开1024个文件，当然这个限制数其实是可以设置的，这个就先不给大家介绍了，当然除了进程有最大文件数限制外，其实对于整个Linux系统来说，也有最大限制，那么关于这些问题，如果后面的章节内容中涉及到了再给大家进行介绍。
所以对于一个进程来说，文件描述符是一种有限资源，文件描述符是从0开始分配的，譬如说进程中第一个被打开的文件对应的文件描述符是0、第二个文件是1、第三个文件是2、第4个文件是3……以此类推，所以由此可知，文件描述符数字最大值为1023（0~1023）。每一个被打开的文件在同一个进程中都有一个唯一的文件描述符，不会重复，如果文件被关闭后，它对应的文件描述符将会被释放，那么这个文件描述符将可以再次分配给其它打开的文件、与对应的文件绑定起来。
每次给打开的文件分配文件描述符都是从最小的没有被使用的文件描述符（0~1023）开始，当之前打开的文件被关闭之后，那么它对应的文件描述符会被释放，释放之后也就成为了一个没有被使用的文件描述符了。
当我们在程序中，调用open函数打开文件的时候，分配的文件描述符一般都是从3开始，这里大家可能要问了，上面不是说从0开始的吗，确实是如此，但是0、1、2这三个文件描述符已经默认被系统占用了，分别分配给了系统标注输入（0）、标注输出（1）以及标准错误（2），关于这个问题，这里不便给大家说太多，毕竟这是后面的内容，这里只是给大家提一下，后面遇到了再具体讲解。
Tips：Linux系统下，一切皆文件，也包括各种硬件设备，使用open函数打开任何文件成功情况下便会返回对应的文件描述符fd。每一个硬件设备都会对应于Linux系统下的某一个文件，把这类文件称为设备文件。所以设备文件对应的其实是某一硬件设备，应用程序通过对设备文件进行读写等操作、来使用、操控硬件设备，譬如LCD显示器、串口、音频、键盘等。
标准输入一般对应的是键盘，可以理解为0便是打开键盘对应的设备文件时所得到的文件描述符；标准输出一般指的是LCD显示器，可以理解为1便是打开LCD设备对应的设备文件时所得到的文件描述符；而标准错误一般指的也是LCD显示器。
2.3open打开文件
在Linux系统中要操作一个文件，需要先打开该文件，得到文件描述符，然后再对文件进行相应的读写操作（或其他操作），最后在关闭该文件；open函数用于打开文件，当然除了打开已经存在的文件之外，还可以创建一个新的文件，函数原型如下所示：

1. #include <sys/types.h>
   
2. #include <sys/stat.h>
   
3. #include <fcntl.h>
   
4. 
   
5. int open(const char *pathname, int flags);
   
6. int open(const char *pathname, int flags, mode_t mode);

复制代码

在Linux系统下，可以通过man命令（也叫man手册）来查看某一个Linux系统调用的帮助信息，man命令可以将该系统调用的详细信息显示出来，譬如函数功能介绍、函数原型、参数、返回值以及使用该函数所需包含的头文件等信息；man更像是一份帮助手册，所以也把它称为man手册，当我们需要查看某个系统调用的功能介绍、使用方法时，不用在上网到处查找，直接通过man命令便可以搞定，man命令用法如下所示：

1. man 2 open                #查看open函数的帮助信息

复制代码

图 2.3.1 查看open函数帮助信息

Tips：man命令后面跟着两个参数，数字2表示系统调用，man命令除了可以查看系统调用的帮助信息外，还可以查看Linux命令（对应数字1）以及标准C库函数（对应数字3）所对应的帮助信息；最后一个参数open表示需要查看的系统调用函数名。
由于篇幅有限，此截图只是其中一部分内容，从图中可知，open函数有两种原型？这是为什么呢？关于这个问题笔者一开始也不理解，大家都知道C语言是不支持重载的，那既然这样，只有一种解释了，那就是可变参函数；对于C语言中的可变参函数，对此不了解的朋友可以自行百度，本文档不作说明！
所以由此可知，在应用程序中调用open函数即可传入2个参数（pathname、flags）、也可传入3个参数（pathname、flags、mode），但是第三个参数mode需要在第二个参数flags满足条件时才会有效，稍后将对此进行说明；从图 2.3.1可知，在应用程序中使用open函数时，需要包含3个头文件“#include <sys/types.h>”、“#include <sys/stat.h>”、“#include <fcntl.h>”。
函数参数和返回值含义如下：
pathname：字符串类型，用于标识需要打开或创建的文件，可以包含路径（绝对路径或相对路径）信息，譬如："./src_file"（当前目录下的src_file文件）、"/home/dengtao/hello.c"等；如果pathname是一个符号链接，会对其进行解引用。
flags：调用open函数时需要提供的标志，包括文件访问模式标志以及其它文件相关标志，这些标志使用宏定义进行描述，都是常量，open函数提供了非常多的标志，我们传入flags参数时既可以单独使用某一个标志，也可以通过位或运算（|）将多个标志进行组合。这些标志介绍如下：

表 2.3.1 open函数flags参数值介绍

以上给大家介绍了一些比较常用的标志，open函数的flags标志并不止这些，还有很多标志这里并没有给大家进行介绍，譬如O_APPEND、O_ASYNC、O_DSYNC、O_NOATIME、O_NONBLOCK、O_SYNC以及O_TRUNC等，对于这些没有提及到的标志，在后面学习过程中，也会给大家慢慢介绍。对于初学者来说，我们需要把表 2.3.1中所列出的这些标志给弄明白、理解它们的作用和含义。
Tips：不同内核版本所支持的flags标志是存在差别的，譬如说新版本内核所支持的标志可能在老版本是不支持的，亦或者老版本支持的标志在新版本已经被取消、替代，man手册中对一些标志是从哪个版本开始支持的有简单地说明，读者可以自行阅读！
前面我们说过，flags参数时既可以单独使用某一个标志，也可以通过位或运算（|）将多个标志进行组合，譬如：

1. open("./src_file", O_RDONLY)                                        //单独使用某一个标志
   
2. open("./src_file", O_RDONLY | O_NOFOLLOW)        //多个标志组合

复制代码

mode：此参数用于指定新建文件的访问权限，只有当flags参数中包含O_CREAT或O_TMPFILE标志时才有效（O_TMPFILE标志用于创建一个临时文件）。权限对于文件来说是一个很重要的属性，那么在Linux系统中，我们可以通过touch命令新建一个文件，此时文件会有一个默认的权限，如果需要修改文件权限，可通过chmod命令对文件权限进行修改，譬如在Linux系统下我们可以使用"ls -l"命令来查看到文件所对应的权限。
当我们调用open函数去新建一个文件时，也需要指定该文件的权限，而mode参数便用于指定此文件的权限，接下来看看我们该如何通过mode参数来表示文件的权限，首先mode参数的类型是mode_t，这是一个u32无符号整形数据，权限表示方法如下所示：

图 2.3.2 mode权限表示方法

我们从低位从上看，每3个bit位分为一组，分别表示：
O---这3个bit位用于表示其他用户的权限；
G---这3个bit位用于表示同组用户（group）的权限，即与文件所有者有相同组ID的所有用户；
U---这3个bit位用于表示文件所属用户的权限，即文件或目录的所属者；
S---这3个bit位用于表示文件的特殊权限，文件特殊权限一般用的比较少，这里就不给大家细讲了。
关于什么是文件所属用户、同组用户以及其他用户，这些都是Linux操作系统相关的基础知识，相信大家都理解这些概念；3个bit位中，按照rwx顺序来分配权限位（特殊权限除外），最高位（权值为4）表示读权限，为1时表示具有读权限，为0时没有读权限；中间位（权值为2）表示写权限，为1时表示具有写权限，为0时没有写权限；最低位（权值为1）表示执行权限，为1时表示具有可执行权限，为0时没有执行权限。接下来我们举几个例子（特殊权限这里暂时不管，其S字段全部为0）：
最高权限表示方法：111111111（二进制表示）、777（八进制表示）、511（十进制表示）；
最高权限这里意味着所有用户对此文件都具有读权限、写权限以及执行权限。
111000000（二进制表示）：表示文件所属者具有读、写、执行权限，而同组用户和其他用户不具有任何权限；
100100100（二进制表示）：表示文件所属者、同组用户以及其他用户都具有读权限，但都没有写、执行权限。
Tips：open函数O_RDONLY、O_WRONLY以及O_RDWR这三个标志表示以什么方式去打开文件，譬如以只写方式打开（open函数得到的文件描述符只能对文件进行写操作，不能读）、以只读方式打开（open函数得到的文件描述符只能对文件进行读操作，不能写）、以可读可写方式打开（open函数得到的文件描述符可对文件进行读和写操作）；与文件权限之间的联系，只有用户对该文件具有相应权限时，才可以使用对应的标志去打开文件，否则会打开失败！譬如，我们的程序对该文件只有只读权限，那么执行open函数使用O_RDWR或O_WRONLY标志将会失败。关于文件权限等相关问题，将会在第五章中给大家介绍。
关于文件权限表示方法的问题，以上就给大家介绍这么多，在实际编程中，我们可以直接使用Linux中已经定义好的宏，不同的宏定义表示不同的权限，如下所示：

表 2.3.2 open函数文件权限宏

这些宏既可以单独使用，也可以通过位或运算将多个宏组合在一起，譬如：

1. S_IRUSR | S_IWUSR | S_IROTH

复制代码

返回值：成功将返回文件描述符，文件描述符是一个非负整数；失败将返回-1。
以上就把open函数相关的基础知识给大家介绍完了，包括函数返回值、参数等信息，当然在后面的章节内容中，我们还会更加深入地给大家讲解open函数相关的知识点；接下来我们看一些open函数的简答使用示例。
open函数使用示例
(1)使用open函数打开一个已经存在的文件（例如当前目录下的app.c文件），使用只读方式打开：

1. int fd = open("./app.c", O_RDONLY)
   
2. if (-1 == fd)
   
3.         return fd;

复制代码

(2)使用open函数打开一个已经存在的文件（例如当前目录下的app.c文件），使用可读可写方式打开：

1. int fd = open("./app.c", O_RDWR)
   
2. if (-1 == fd)
   
3.         return fd;

复制代码

(3)使用open函数打开一个指定的文件（譬如/home/dengtao/hello），使用可读可写方式,如果该文件是一个符号链接文件，则不对其进行解引用，直接返回错误：

1. int fd = open("/home/dengtao/hello", O_RDWR | O_NOFOLLOW);
   
2. if (-1 == fd)
   
3.         return fd;

复制代码

(4)使用open函数打开一个指定的文件（譬如/home/dengtao/hello），如果该文件不存在则创建该文件，创建该文件时，将文件权限设置如下：
文件所属者拥有读、写、执行权限；
同组用户与其他用户只有读权限。
使用可读可写方式打开：

1. int fd = open("/home/dengtao/hello", O_RDWR | O_CREAT, S_IRWXU | S_IRGRP | S_IROTH);
   
2. if (-1 == fd)
   
3.         return fd;

复制代码

2.4write写文件
调用write函数可向打开的文件写入数据，其函数原型如下所示（可通过"man 2 write"查看）：

1. #include <unistd.h>
   
2. 
   
3. ssize_t write(int fd, const void *buf, size_t count);

复制代码

首先使用write函数需要先包含unistd.h头文件。
函数参数和返回值含义如下：
fd：文件描述符。关于文件描述符，前面已经给大家进行了简单地讲解，这里不再重述！我们需要将进行写操作的文件所对应的文件描述符传递给write函数。
buf：指定写入数据对应的缓冲区。
count：指定写入的字节数。
返回值：如果成功将返回写入的字节数（0表示未写入任何字节），如果此数字小于count参数，这不是错误，譬如磁盘空间已满，可能会发生这种情况；如果写入出错，则返回-1。
对于普通文件（我们一般操作的大部分文件都是普通文件，譬如常见的文本文件、二进制文件等），不管是读操作还是写操作，一个很重要的问题是：从文件的哪个位置开始进行读写操作？也就是IO操作所对应的位置偏移量，读写操作都是从文件的当前位置偏移量处开始，当然当前位置偏移量可以通过lseek系统调用进行设置，关于此函数后面再讲；默认情况下当前位置偏移量一般是0，也就是指向了文件起始位置，当调用read、write函数读写操作完成之后，当前位置偏移量也会向后移动对应字节数，譬如当前位置偏移量为1000个字节处，调用write()写入或read()读取500个字节之后，当前位置偏移量将会移动到1500个字节处。
2.5read读文件
调用read函数可从打开的文件中读取数据，其函数原型如下所示（可通过"man 2 read"查看）：

1. #include <unistd.h>
   
2. 
   
3. ssize_t read(int fd, void *buf, size_t count);

复制代码

首先使用read函数需要先包含unistd.h头文件。
函数参数和返回值含义如下：
fd：文件描述符。与write函数的fd参数意义相同。
buf：指定用于存储读取数据的缓冲区。
count：指定需要读取的字节数。
返回值：如果读取成功将返回读取到的字节数，实际读取到的字节数可能会小于count参数指定的字节数，也有可能会为0，譬如进行读操作时，当前文件位置偏移量已经到了文件末尾。实际读取到的字节数少于要求读取的字节数，譬如在到达文件末尾之前有30个字节数据，而要求读取100个字节，则read读取成功只能返回30；而下一次再调用read读，它将返回0（文件末尾）。
2.6close关闭文件
可调用close函数关闭一个已经打开的文件，其函数原型如下所示（可通过"man 2 close"查看）：
#include <unistd.h>

1. int close(int fd);

复制代码

首先使用close函数需要先包含unistd.h头文件，当我们对文件进行IO操作完成之后，后续不再对文件进行操作时，需要将文件关闭。
函数参数和返回值含义如下：
fd：文件描述符，需要关闭的文件所对应的文件描述符。
返回值：如果成功返回0，如果失败则返回-1。
除了使用close函数显式关闭文件之外，在Linux系统中，当一个进程终止时，内核会自动关闭它打开的所有文件，也就是说在我们的程序中打开了文件，如果程序终止退出时没有关闭打开的文件，那么内核会自动将程序中打开的文件关闭。很多程序都利用了这一功能而不显式地用close关闭打开的文件。
显式关闭不再需要的文件描述符往往是良好的编程习惯，会使代码在后续修改时更具有可读性，也更可靠，进而言之，文件描述符是有限资源，当不再需要时必须将其释放、归还于系统。
2.7lseek
对于每个打开的文件，系统都会记录它的读写位置偏移量，我们也把这个读写位置偏移量称为读写偏移量，记录了文件当前的读写位置，当调用read()或write()函数对文件进行读写操作时，就会从当前读写位置偏移量开始进行数据读写。
读写偏移量用于指示read()或write()函数操作时文件的起始位置，会以相对于文件头部的位置偏移量来表示，文件第一个字节数据的位置偏移量为0。
当打开文件时，会将读写偏移量设置为指向文件开始位置处，以后每次调用read()、write()将自动对其进行调整，以指向已读或已写数据后的下一字节，因此，连续的调用read()和write()函数将使得读写按顺序递增，对文件进行操作。我们先来看看lseek函数的原型，如下所示（可通过"man 2 lseek"查看）：

1. #include <sys/types.h>
   
2. #include <unistd.h>
   
3. 
   
4. off_t lseek(int fd, off_t offset, int whence);

复制代码

首先调用lseek函数需要包含<sys/types.h>和<unistd.h>两个头文件。
函数参数和返回值含义如下：
fd：文件描述符。
offset：偏移量，以字节为单位。
whence：用于定义参数offset偏移量对应的参考值，该参数为下列其中一种（宏定义）：
&#61548;SEEK_SET：读写偏移量将指向offset字节位置处（从文件头部开始算）；
&#61548;SEEK_CUR：读写偏移量将指向当前位置偏移量 + offset字节位置处，offset可以为正、也可以为负，如果是正数表示往后偏移，如果是负数则表示往前偏移；
&#61548;SEEK_END：读写偏移量将指向文件末尾 + offset字节位置处，同样offset可以为正、也可以为负，如果是正数表示往后偏移、如果是负数则表示往前偏移。
返回值：成功将返回从文件头部开始算起的位置偏移量（字节为单位），也就是当前的读写位置；发生错误将返回-1。
使用示例：
(1)将读写位置移动到文件开头处：

1. off_t off = lseek(fd, 0, SEEK_SET);
   
2. if (-1 == off)
   
3.         return -1;

复制代码

(2)将读写位置移动到文件末尾：

1. off_t off = lseek(fd, 0, SEEK_END);
   
2. if (-1 == off)
   
3.         return -1;

复制代码

(3)将读写位置移动到偏移文件开头100个字节处：

1. off_t off = lseek(fd, 100, SEEK_SET);
   
2. if (-1 == off)
   
3.         return -1;

复制代码

(4)获取当前读写位置偏移量：

1. off_t off = lseek(fd, 0, SEEK_CUR);
   
2. if (-1 == off)
   
3.         return -1;

复制代码

函数执行成功将返回文件当前读写位置。
2.8练习
本章给大家介绍了文件IO中的基础知识，包括文件IO常用到的系统调用open()、read()、write()、close()以及lseek()，当然关于这些系统调用所涉及到的知识点并没有讲完，本章所介绍的都是一些基础知识内容，在后面的学习过程中，我们会一一给大家深入讲解文件IO中的一些问题。
学完本章内容后，我们来做一些简单地文件IO编程练习，以巩固、提高大家所学知识内容，以下笔者给大家准备了4个简单地实战编程例子，大家可以尝试自己独立完成。
简单地编程实战例子
(1)打开一个已经存在的文件（例如src_file），使用只读方式；然后打开一个新建文件（例如dest_file），使用只写方式，新建文件的权限设置如下：
文件所属者拥有读、写、执行权限；
同组用户与其他用户只有读权限。
从src_file文件偏移头部500个字节位置开始读取1Kbyte字节数据，然后将读取出来的数据写入到dest_file文件中，从文件开头处开始写入，1Kbyte字节大小，操作完成之后使用close显式关闭所有文件，然后退出程序。
(2)通过open函数判断文件是否存在（例如test_file），并将判断结果显示出来。
(3)新建一个文件（例如new_file），新建文件的权限设置为：
文件所属者拥有读、写、执行权限；
同组用户与其他用户只有读权限。
使用只写方式打开文件，将文件前1Kbyte字节数据填充为0x00，将下1Kbyte字节数据填充为0xFF，操作完成之后显式关闭文件，退出程序。
(4)打开一个已经存在的文件（例如test_file），通过lseek函数计算该文件的大小，并打印出来。
以上就是本章内容给大家整理的几个简单地编程实战例子，大家可以根据本章所需知识内容将这几个例子独立完成，在本文档配套的资料包中，笔者会给出相应的示例代码，建议大家先自己独立思考，如果实在不知再参考笔者给出的示例代码。
vscode编写代码
前面给大家介绍了vscode，它是一款非常好用的代码编辑器，我们可以在Ubuntu系统下使用vscode软件进行的代码编写，首先在Ubuntu系统下创建一个文件夹作为vscode的工作目录，譬如笔者在家目录下创建了一个名为vscode_ws的目录，将其作为vscode的工作目录，如下所示：

图 2.8.1 创建vscode工作目录

在Ubuntu系统下打开vscode软件，如下所示：

图 2.8.2 打开vscode软件

选择上边菜单栏，点击“文件--->打开文件夹”，在弹出来的页面中选择需要打开的文件夹，这里我们选择前面创建好的vscode_ws目录，如下所示：

图 2.8.3 打开工作目录

接下来在工作目录下创建一个文件夹作为本章编程实战例程源码存放目录，直接在vscode软件进行创建即可，这里笔者将其命名为1_chapter，如下所示：

图 2.8.4 在工作目录下创建一个文件夹

接下来在1_chapter目录下创建一个.c源文件，将其命名为testApp_1.c，此源文件对应上面第一个(1)编程实战例子，如下所示：

图 2.8.5 创建C程序源文件

点击打开testApp_1.c文本编辑页面，接下来就可以在testApp_1.c源文件中编写第一个实战例子对应的源代码了，以下是笔者给大家提供的一份示例代码，大家可以进行参考，但还是希望大家能够根据本章所学知识独立完成代码编写：
示例代码 2.8.1 编程实战例子1

1. /***************************************************************
   
2. Copyright &#169; ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
   
3. 文件名 : testApp_1.c
   
4. 作者 : 邓涛
   
5. 版本 : V1.0
   
6. 描述 :
   
7. 论坛 : <a href="www.openedv.com" target="_blank">www.openedv.com</a>
   
8. 日志 : 初版V1.0 2021/01/05 创建
   
9. ***************************************************************/
   
10. 
    
11. #include <sys/types.h>
    
12. #include <sys/stat.h>
    
13. #include <fcntl.h>
    
14. #include <unistd.h>
    
15. #include <stdio.h>
    
16. 
    
17. int main(void)
    
18. {
    
19.     char buffer[1024];
    
20.     int fd1, fd2;
    
21.     int ret;
    
22. 
    
23.     /* 打开src_file文件 */
    
24.     fd1 = open("./src_file", O_RDONLY);
    
25.     if (-1 == fd1) {
    
26.         printf("Error: open src_file failed!\n");
    
27.         return -1;
    
28.     }
    
29. 
    
30.     /* 新建dest_file文件并打开 */
    
31.     fd2 = open("./dest_file", O_WRONLY | O_CREAT | O_EXCL,
    
32.                 S_IRWXU | S_IRGRP | S_IROTH);
    
33.     if (-1 == fd2) {
    
34.         printf("Error: open dest_file failed!\n");
    
35.         ret = -1;
    
36.         goto err1;
    
37.     }
    
38. 
    
39.     /* 将src_file文件读写位置移动到偏移文件头500个字节处 */
    
40.     ret = lseek(fd1, 500, SEEK_SET);
    
41.     if (-1 == ret)
    
42.         goto err2;
    
43. 
    
44.     /* 读取src_file文件数据，大小1KByte */
    
45.     ret = read(fd1, buffer, sizeof(buffer));
    
46.     if (-1 == ret) {
    
47.         printf("Error: read src_file filed!\n");
    
48.         goto err2;
    
49.     }
    
50. 
    
51.     /* 将dest_file文件读写位置移动到文件头 */
    
52.     ret = lseek(fd2, 0, SEEK_SET);
    
53.     if (-1 == ret)
    
54.         goto err2;
    
55. 
    
56.     /* 将buffer中的数据写入dest_file文件，大小1KByte */
    
57.     ret = write(fd2, buffer, sizeof(buffer));
    
58.     if (-1 == ret) {
    
59.         printf("Error: write dest_file failed!\n");
    
60.         goto err2;
    
61.     }
    
62. 
    
63.     printf("OK: test successful\n");
    
64.     ret = 0;
    
65. 
    
66. err2:
    
67.     close(fd2);
    
68. 
    
69. err1:
    
70.     close(fd1);
    
71.     return ret;
    
72. }

复制代码

此代码中用到了库函数printf，是一个格式化输出函数，用于将格式化打印信息输出显示到屏幕上（终端），使用此函数需要包含标准I/O库头文件<stdio.h>，对于有C语言编程经验的读者来说，如果对该函数的使用方法并不了解，可以查看4.8.1小节内容。
编译源码文件
代码编写完成之后，接下来我们需要对源代码进行编译，在vscode中点击上边菜单“终端--->新终端”打开一个终端，打开的终端将会在下面显示出来，如下所示：

图 2.8.6 在vscode中打开终端

vscode提供了终端功能，这样就可以不使用Ubuntu自带的终端了，非常的方便、不需要在Ubuntu终端和vscode软件之间进行切换，进入到1_chapter目录下，如下所示：

图 2.8.7 进入1_chapter目录

在该目录下我们直接使用Ubuntu系统提供的gcc编译器对源文件进行编译，编译生成一个可在Ubuntu系统下运行的可执行文件，执行如下命令：

1. gcc -o testApp_1 testApp_1.c

复制代码

gcc是Ubuntu系统下所使用的C语言编译器，-o选项指定编译生成的可执行文件的名字，testApp_1.c表示需要进行编译的C语言源文件，gcc命令后面可以携带很多的编译相关的选项，这里不给大家介绍这个内容，这不是本文档我们需要去了解的重点，如果后面有机会可以给大家介绍下。编译完成之后会生成对应的可执行文件，如下所示：

图 2.8.8 编译源文件

运行可执行文件测试
编译完成之后，接下来可以运行测试了，首先我们先准备一个文件src_file，这个是例子要求需要打开一个已经存在的文件，文件大小大于或等于1Kbyte，这里笔者已经将src_file文件放置到1_chapter目录下了，如下所示：

图 2.8.9 准备好一个测试需要用到的文件

直接在当前目录下运行testApp_1可执行文件：

图 2.8.10 运行testApp_1可执行文件

运行成功之后会生成dest_file文件，这就是testApp_1.c源码中使用open创建的新文件，通过查看它的权限可知与源码中设置的权限是相同的，文件大小为1Kbyte，其中这1Kbyte字节数据是从src_file文件中读取过来的。
剩下的几个例子希望大家自己独立完成。
Tips：最后再给大家说一点，就是关于函数返回值的问题，我们可以发现，本章给大家所介绍的这些函数都是有返回值的，其实不管是Linux应用编程API函数，还是驱动开发中所使用到的函数，基本上都是有返回值的，返回值的作用就是告诉开发人员此函数执行的一个状态是怎样的，执行成功了还是失败了，在Linux系统下，绝大部分的函数都是返回0作为函数调用成功的标识、而返回负数（譬如-1）表示函数调用失败，如果大家学习过驱动开发，想必对此并不陌生，所以很多时候可以使用如下的方式来判断函数执行成功还是失败：

1. if (func()) {
   
2.         //执行失败
   
3. } else {
   
4.         //执行成功
   
5. }

复制代码

当然以上说的是大部分情况，并不是所有函数都是这样设计，所以呢，这里笔者也给大家一个建议，自己在进行编程开发的时候，自定义函数也可以使用这样的一种方法来设计你的函数返回值，不管是裸机程序亦或是Linux应用程序、驱动程序。

ZQC

2.8 练习 的第三个，向文件中写入0x00是怎么操作的，能写入0x00吗？

xiaotaotao

ZQC 发表于 2022-1-18 13:02
2.8 练习 的第三个，向文件中写入0x00是怎么操作的，能写入0x00吗？

怎么不能写入