linux环境：C编程文件操作

---

C语言标准函数库文件操作函数

1. 打开文件：foen(文件名，打开格式)
2. 关闭文件：fclose(文件名)
3. 无格式读文件：fread(目标地址，读取单位大小，读取个数，源文件指针)
4. 无格式写文件：fwrite(源地址，读取单位大小，读取个数，目标文件指针)
5. 格式化读文件：fscanf(源文件指针，带格式控制的字符串，目的变量地址…)
6. 格式化写文件：fprintf(目标文件指针，带格式控制的字符串，源变量)
7. 读文件字符：fgetc(源文件指针)
8. 写文件字符：fputc(字符，目标文件指针)
9. 读文件字符串：fgets(源文件指针)
10. 写文件字符串：fputs(字符串，目标文件指针)
11. 文件结束指示：feof(文件指针)
12. 文件指针定位：ftell(文件指针)返回当前文件指针距离文件开始处的字节数
13. 文件指针重定位：fseek(文件指针，偏移量，起始点)起始点可以是文件头0，文件尾2，文件指针当前位置1
14. 文件指针复原rewind(文件指针)
15. 格式化写字符串函数：sprintf(字符串指针，格式控制，变量)
16. 格式化读字符串函数：fscanf(字符串指针，带格式控制的字符串，目的变量地址…)

使用方法和在windows环境下一致

---

Linux目录操作

目录文件查找

首先需要理解：linux系统中的目录也是以文件的方式存储，在目录文件中存储了该目录下的文件的信息，包括文件名，文件inode编号，文件类型等等，姑且把这些信息称为一个文件的索引信息。如果想要找到某个文件，首先需要找到这个文件所在目录的目录文件。

接下来就可以理解linux下打开目录查找文件的流程了：

1. 函数DIR *opendir(目录路径)可以根据路径查找打开对应的目录文件，返回指向该目录文件流的结构体指针DIR*，DIR数据结构存储了当前打开的目录文件的相关信息，目录文件的大小，起始地址等等。
2. 获得目录流的结构体指针后，我们就可以使用dirent * readdir(目录流指针)读取目录文件中的内容，依次获取每个文件的索引信息。
3. 为了保证目录文件不至于过大，文件的索引信息中只存了少量必要信息，所以想要获得文件的详细信息，在通过dirent结构体知道了文件名只后，我们需要通过int stat(包含路径的完整文件名, stat结构体指针);来获取文件的详细信息，
4. 可以通过void rewinddir(DIR *dir)重定位目录流指针来重新读取当前目录下的文件索引信息
5. 和文件流指针一样，使用完之后应使用 closedir(DIR *dir)关闭目录流指针DIR*

其他目录操作

• 修改权限int chmod(const char* path, mode_t mode);//path:文件路径 mode 数字权限
• char *getcwd(char *buf, size_t size); //获取当前目录，相当于 pwd 命令
  将当前的工作目录绝对路径复制到参数 buf 所指的内存空间，参数 size 为 buf
  的空间大小,空间不足返回NULL，buf为NULL时系统使用malloc自动分配内存
• int chdir(const char *path); //修改当前目录，即切换目录，相当于 cd 命令

---

基于文件描述符的Linux文件操作

基本文件操作-打开、关闭与读写

除了C标准库中的文件操作函数，linux环境下提供了另外一套直接根据文件描述符进行文件操作的函数。直接使用文件描述符对文件操作，可以提高程序的运行效率。

1. 打开文件int open(const char *pathname, int flags); //文件名 打开方式
2. 打开文件int open(const char *pathname, int flags, mode_t mode);
3. 关闭文件int close(int fd);
4. 读文件ssize_t read(int fd, void *buf, size_t count);//文件描述词 缓冲区 长度
5. 写文件ssize_t write(int fd, const void buf, size_t count);
   打开和关闭函数与标准函数基本类似，区别在于由FILE类型的文件指针变成了int类型的文件描述符，文件权限表示也不一样。
   读写文件类似fread fwrite，不同之处在于不再区分单位长度和单位个数，而是直接以总字节长度作为参数。

改变文件大小

• 直接改变文件大小：使用函数int ftruncate(int fd, off_t length);
  函数 ftruncate 会将参数 fd 指定的文件大小改为参数 length 指定的大小。参数 fd 为已打开的文件描述词，而且必须是以写入模式打开的文件。如果原来的文件大小比参数 length 大，则超过的部分会被删去。执行成功则返回 0，失败返回-1

• 间接扩大文件：使用文件指针定位函数lseek
  off_t lseek(int fd, off_t offset, int whence);//fd 文件描述词,offset为偏移量，whence为基准地址，0代表文件头，1代表文件指针所在，2代表文件尾

  利用该函数可以实现文件空洞（对一个新建的空文件，可以定位到偏移文件开头 1024 个字节的地方，在写入一个字符，则相当于给该文件分配了 1025 个字节的空间，形成文件空洞）通常用于多进程间通信的时候的共享内存。

文件描述符与文件指针的转换

• FILE* -> int :int fileno(FILE * file);

• int ->FILE*:FILE *fdopen(int fd);

获取文件信息

• 通过文件指针获取：
  int stat(const char *file_name, struct stat *buf); //文件名 stat 结构体指针
• 通过文件描述符获取：
  int fstat(int fd, struct stat *buf); //文件描述符stat 结构体指针

文件描述符复制

原理解析：

• linux系统中，包括设备在内所有资源均是通过文件格式进行管理的。
• 系统访问相应的文件的时候，需要首先打开文件。
• 所有对已打开的文件的操作，均需要通过文件描述符进行，FILE*指针最后也是由系统转为文件描述符进行操作的。
• 同一文件往往会有不同线程同时访问，Linux采用引用计数的方式进行管理，即文件只打开一份，此后每有一个新的打开请求，只返回一个新的文件描述符，同时该文件的引用计数加一。
• 关闭文件同理，仅仅释放文件描述符，即更新进程的文件描述符表中该描述符的状态，当文件的引用计数为0时才真正执行关闭文件的操作。
• 文件描述符，仅仅只是一个整数序号，和变量名无关，只要序号相同，就是同一个文件描述符。

理解上述原理后，我们来看文件描述符的复制

使用 = 直接复制

int fd0=open("test.c",O_RDWR | O_CREAT);
int fd1=fd0;

这种情况下，fd1和fd0的值相同，是同一个整数，也就是说两者是同一个文件描述符，test.c文件的引用计数不增加，虽然都可以对文件进行访问，但是只要对任意一个执行close()操作，这个整数代表的描述符就和该文件脱离联系，通过fd0，fd1两个变量均不能再访问test.c文件。

使用dup()函数复制

函数原理分析：

dup函数接收一个文件描述符作为参数，查找对应的文件。
如果该文件描述符没有对应打开的文件则返回-1
有对应的文件，则返回当前未被使用的最小文件描述符，同时该文件的引用计数加1

样例程序：

	int main()
{
    int fd1 = open("dup.doc", O_RDWR | O_CREAT);
    int fd2 = dup(fd1);
    
    printf("fd1=%d\nfd2=dup(fd1)\nfd2==%d\n",fd1,fd2);
    
    close(fd1);
    printf("fd1 closed!\n");
    
    write(fd2,"HELLO WORLD!",13);
    printf("write dup.doc by fd2!\n");
}

执行效果如下：

fd1=3
fd2=dup(fd1)
fd2==4
fd1 closed!
write dup.doc by fd2!

使用cat命令查看dup.doc文件：

[jzk@ubuntu ~/code/dup]$ cat dup.doc
HELLO WORLD![jzk@ubuntu ~/code/dup]$ 

可以看到在关闭fd1后，我们通过fd2仍然可以对文件进行读写。

使用dup2()函数复制

函数原理分析：

int dup2(int oldfd, int newfd)接收两个文件描述符作为参数

• 第一个参数oldfd是源文件描述符，应该对应一个打开的文件，如果该文件描述符没有对应打开的文件则报错返回-1
• 第二个参数newfd是目的文件描述符，如果newfd等于oldfd则返回这个值。如果newfd已经关联其他文件，则执行close(newfd)操作，然后把newfd与oldfd对应的文件进行关联，该文件的引用计数加1，返回newfd

重定向标准输入输出到文件

预备知识：Linux系统中输入输出设备同样是通过文件描述符管理，其中标准输入stdin，标准输出stdout，标准错误输出stderr默认的文件描述符是0，1，2，分别用STDIN_FILENO、STDOUT_FILENO 和 STDERR_FILENO 三个宏表示
值得注意的是，对于所有调用标准输入输出的函数，比如printf(),puts,scanf(),perror()等等，它们只认0，1，2这三个描述符，而不关注这三个描述符关联的对象。这样我们就可以通过改变0，1，2这三个文件描述符关联的文件，从而实现对标准输入输出的重定向。
同时要注意，一旦关闭标准输入输出之后，就手动不能打开了，所以，如果在重定向之后需要再使用标准输入输出，需要先将其复制给其文件描述符来维持标准输入输出文件的打开。

样例程序：

int main()
{
    //备份标准输入
    int ind = dup(0);
    //备份标准输出
    int outd = dup(1);
    
    
    int fd = open("test.doc",O_RDWR|O_CREAT);
 
    //将原本标准输出的文件描述符与fd关联起来
    dup2(fd,1);
    printf("you will see me in test.doc.\n");

	//重新把标准输出文件和1联系起来
    dup2(outd,1);
    printf("you will see me on the screen.\n");
    
    //将文件指针重定位到文件头
    lseek(fd,0,0);
   
    //将原本标准输入的文件描述符与fd关联起来
    dup2(fd,0);

    char str[30]={0};
   //从文件中读取字符串
    gets(str);
    printf("this is a string from the file:\t%s\n",str);
   
    //重新把标准输入的文件描述符与0联系起来
    dup2(ind,0);

    //测试是否重新回到了标准输入输出流
    printf("input test：input a string\n");
    scanf("%s",str);
    printf("%s\n",str);
    return 0;
}

执行效果如下：

you will see me on the screen.
this is a string from the file:	you will see me in test.doc.
input test：input a string
success!
success!

查看test.doc中的内容：

[jzk@ubuntu ~/code/stdio]$ cat test.doc 
you will see me in test.doc.
[jzk@ubuntu ~/code/stdio]$ 

---

MMAP文件映射

MMP文件映射的原理是使用DMA通道技术，在地址A与地址B之间构造映射。
当我们在地址A为起始的映射区读写操作时，DMA控制器可以将该读写操作同步到地址B起始的映射区，从而实现了数据高效传输。
其中地址A和B可以一个在内存，一个在外存，一个在用户空间，一个在内核空间，灵活性很强。

调用形式如下：
void* mmap ( void * addr , size_t len , int prot , int flags , int fd , off_t offset )

参数解释：

1. 第一个参数addr指定文件应被映射到进程空间的起始地址，一般被指定一个空指针，此时选择起始地址的任务留给内核来完成.
2. 第二个参数len指定映射区的大小，从被映射文件开头offset个字节开始算起，注意该值加上offset值后不能超过映射文件的大小
3. 第三个参数prot指定映射的内存段的访问权限，可读PROT_READ可写PROT_WRITE、可执行PROT_EXEC或不可访问PROT_NONE,可以使用或运算进行组合
4. 第四个参数flags指定映射对象的类型，映射选项和映射页是否可以共享，一般为MAP_SHARED
5. 第五个参数fd为文件描述符
6. 第六个参数offset为文件中的映射区从文件开始处算起的偏移量，必须是物理页面大小4K的整数倍

注意：数据传输完毕后，需要使用int munmap(映射文件描述符，映射区大小)解除映射，解除成功返回0，否则返回-1

---

管道文件通信

原理：
管道通信为半双工通信，通信双方通过交替读写管道文件，实现数据传递。通过两个不同进程中的各自文件描述符指向同一个文件，来实现读写同一对象。

管道文件基本操作

1. 创建管道文件的命令：mkfifo filename
2. 删除管道文件的命令：unlink filename
3. 管道文件的创建函数：int mkfifo(const char *pathname, mode_t mode);
   参数 pathname 为要创建的 管道文件的全路径名；
   参数 mode 为文件访问权限
4. 管道文件的删除函数：int unlink(const char *pathname);
5. 管道文件的读写打开关闭函数和其他类型的文件相同

管道文件的性质

1. 打开管道文件时分读端和写端，分别用O_RDONLY 和O_WRONLY选项打开。
2. 一个管道文件可以同时被多个进程打开
3. 如果以读取方式打开 FIFO，并且还没有其它进程以写入方式打开 FIFO，open 函数将被阻塞，即不能继续运行，因为没有数据写入文件，无法进行读取
4. 如果以写入方式打开 FIFO，并且还没其它进程以读取方式 FIFO，open 函数也将被阻塞。因为没有进程读取数据，写入的数据可能无法正确送到目的地。
5. 关闭 FIFO 时，如果先关读端，将导致继续往 FIFO 中写数据的进程接收 SIGPIPE 的信号，如果写进程不对该信号进行处理，将导致写进程终止。
6. 如果先关闭写端则从另一端读数据时，read 函数将返回 0，表示管道已经关闭

使用管道实现简单的进程通信

//写进程
int main(int argc,char* argv[])
{
    int fdw;
    fdw=open(argv[1],O_WRONLY);
    printf("I am writer fdw=%d\n",fdw);
    write(fdw,"hello",5);
    return 0;
}
//读进程
int main(int argc,char *argv[])
{
    int fdr;
    fdr=open(argv[1],O_RDONLY);
    printf("I am reader,fdr=%d\n",fdr);
    char buf[128]={0};
    int ret=read(fdr,buf,sizeof(buf));
    printf("ret=%d,buf=%s\n",ret,buf);
    return 0;
}

注意当管道文件只有读端或写端时，进程均会在open函数处阻塞
运行效果：

select()——I/O 多路转接模型

原理：在多进程操作时，如果进程请求的 I/O 操作阻塞，不是真正阻塞 I/O，而是让其中的一个函数等待，则可以用select函数对一组套接字进行监控，如果有就绪信号时发出通知，从而实现多路复用输入/输出模型。

函数原型如下：
int select(int maxfd,fd_set *rdset,fd_set *wrset,fd_set *exset,struct timeval *timeout);

各个参数含义如下：

• 参数maxfd是需要监视的最大的文件描述符值+1
• rdset,wrset,exset分别对应于需要检测的可读文件描述符的集合，可写文件描述符的集 合及异常文件描述符的集合
• struct timeval结构用于描述一段时间长度，如果在这个时间内，需要监视的描述符没有事件发生则函数返回，返回值为0

需要重点注意的时fd_set数据类型，该数据类型是一个文件描述符数组，保存了一系列需要进行监控的文件描述符。

对于fd_set类型通过下面四个宏来操作：

• FD_ZERO(fd_set *fdset) 将指定的文件描述符集清空，在对文件描述符集合进行设置前，必须对其进行初始化，如果不清空，由于在系统分配内存空间后，通常并不作清空处理，所以结果是不可知的。
• FD_SET(fd_set *fdset) 用于在文件描述符集合中增加一个新的文件描述符。
• FD_CLR(fd_set *fdset) 用于在文件描述符集合中删除一个文件描述符。
• FD_ISSET(int fd,fd_set *fdset) 用于测试指定的文件描述符是否就绪。

select函数功能总结：在给定时间对给定的文件集合不断进行测试，返回就绪文件个数，即满足可读，可写或有异常条件待处理的文件。如果time为NULL在一直进行测试，如果time为0则测一次后返回，如果time为定值，在时间耗尽之前持续测试。
然后我们通过FD_ISSET(int fd,fd_set *fdset) 可以测试指定的文件描述符是否就绪，从而应对不同情况进行IO操作。

样例：实现简单的聊天程序：

//chatter1.c
int main(int args,char *argv[])
{
    ARG_CHECK(args,3);
    int fdr,fdw;
    fdr = open(argv[1],O_RDONLY);//存放要接收的信息的文件
    fdw = open(argv[2],O_WRONLY);//存放要发送的信息的文件
    printf("小明,fdr=%d,fdw=%d\n",fdr,fdw);
    char sentence[1024] = {0};

    fd_set rdset;//文件描述符数组，数组中的文件描述符需要手动添加
    int fdReadyNum;//计数
    int ret;    //返回值
    struct timeval tc;//等待时间

    while(1)
    {
        FD_ZERO(&rdset);//清空描述符集合
        FD_SET(STDIN_FILENO,&rdset);//将标准输入流放入集合中
        FD_SET(fdr,&rdset);     //将收到的消息存放文件放入集合中
        tc.tv_sec =999;
        tc.tv_usec = 0;

        fdReadyNum = select(fdr+1,&rdset,NULL,NULL,&tc);

        //监控到就绪描述符
        if(fdReadyNum>0)
        {
            //标准输入就绪，则接收字符串写入fdw中
            if(FD_ISSET(STDIN_FILENO,&rdset))
            {
                memset(sentence,0,sizeof(sentence));

                ret = read(0,sentence,sizeof(sentence)-1);

                //标准输入没有输入内容
                if(0==ret)
                {
                    printf("下线\n");
                    break;
                }
                write(fdw,sentence,strlen(sentence)-1);
            }
            //fdr文件可读，代表管道内有新消息
            if(FD_ISSET(fdr,&rdset))
            {
                memset(sentence,0,sizeof(sentence));
                ret = read(fdr,sentence,sizeof(sentence));
                if(0==ret)
                {
                    printf("系统提示：对方已下线\n");
                    break;
                }
                printf("小红:\n%s\n小明：\n",sentence);
            }
        }
        else
        {
            printf("超时无应答，连接已断开！\n");
        }
    }
    return 0;
}

//chatter2.c
int main(int args,char *argv[])
{
    ARG_CHECK(args,3);

    int fdr,fdw;
    fdw = open(argv[1],O_WRONLY);//存放发送信息的文件
    fdr = open(argv[2],O_RDONLY);//存放接收信息的文件
    printf("小红,fdr=%d,fdw=%d\n",fdr,fdw);     
    char sentence[1024] = {0};

    fd_set rdset;//文件描述符数组，数组中的文件描述符需要手动添加
    int fdReadyNum;//计数
    int ret;    //返回值
     printf("小红：\n");   
    while(1)
    {
        FD_ZERO(&rdset);//清空描述符集合
        FD_SET(STDIN_FILENO,&rdset);//将标准输入流放入集合中
        FD_SET(fdr,&rdset);     //将收到的消息存放文件放入集合中

        fdReadyNum = select(fdr+1,&rdset,NULL,NULL,NULL);
        //标准输入就绪，则接收字符串写入fdw中
        if(FD_ISSET(STDIN_FILENO,&rdset))
        {
            memset(sentence,0,sizeof(sentence));
            
            ret = read(0,sentence,sizeof(sentence)-1);

            //标准输入没有输入内容
            if(0==ret)
            {
                printf("下线\n");
                break;
            }
            write(fdw,sentence,strlen(sentence)-1);
        }
        //fdr文件可读，代表管道内有新消息
        if(FD_ISSET(fdr,&rdset))
        {
            memset(sentence,0,sizeof(sentence));
            ret = read(fdr,sentence,sizeof(sentence));
            if(0==ret)
            {
                printf("系统提示：对方已下线\n");
                break;
            }
            printf("小明：\n%s\n小红:\n",sentence);
        }
    }
    return 0;
}

运行效果：