linux的文件 I/O操作

Linux下的文件类型简述

---

1、文件分类

1、linux 中对目录和设备的操作都是文件操作， 文件分为普通文件， 目录文件， 链接文件和设备文件。
2、普通文件： 也称磁盘文件， 并且能够进行随机的数据存储(能够自由 seek
定位到某一个位置)；
3、管道： 是一个从一端发送数据， 另一端接收数据的数据通道；
4、目录： 也称为目录文件， 它包含了保存在目录中文件列表的简单文件。
5、设备： 该类型的文件提供了大多数物理设备的接口。 它又分为两种类型：字符型设备和块设备。 字符型设备一次只能读出和写入一个字节的数据，包括调制解调器、 终端、 打印机、 声卡以及鼠标； 块设备必须以一定大小的块来读出或者写入数据， 块设备包括 CD-ROM、 RAM 驱动器和磁盘驱动器等， 一般而言， 字符设备用于传输数据， 块设备用于存储数据。
6、链接： 类似于 Windows 的快捷方式和 Linux 里的别名， 指包含到达另一个文件路径的文件。
7、套接字： 在 Linux 中,套接字也可以当作文件来进行处理。

2、标准 I/O 文件操作（基于文件指针带有缓冲区的）

**1. 文件的创建， 打开与关闭**

#include <stdio.h> //头文件包含
FILE *fopen(const char *path,const char *mode); //文件名 模式
int fclose(FILE *stream);

fopen 以 mode 的方式打开或创建文件， 如果成功， 将返回一个文件指针， 失败则返回 NULL.
fopen 创建的文件的访问权限将以 0666 与当前的 umask 结合来确定。

Linux 系统中,mode 里面的’b’(二进制)可以去掉， 但是为了保持与其他系统的兼容性， 建议不要去掉。
ab 和 a+b 为追加模式，这两种模式写数据时都将是在文件末尾添加， 所以比较适合于多进程写同一个文件的情况下保证数据的完整性。
2. 读写文件

数据块读写：

---

#include <stdio.h>
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
size_t fwrite(void *ptr, size_t size, size_t nmemb, FILE *stream);

fread 从文件流 stream 中读取 nmemb 个元素， 写到 ptr 指向的内存中， 每个元素的大小为 size 个字节。
fwrite 从 ptr 指向的内存中读取 nmemb 个元素， 写到文件流 stream 中， 每个元素 size 个字节。所有的文件读写函数都从文件的当前读写点开始读写， 读写完以后， 当前读写点自动往后移动size*nmemb 个字节。
整块 copy， 速度较快， 但是是二进制操作。

格式化读写

---

printf、scanf、
int fprintf(FILE *stream, const char *format, ...); 重点
sprintf(buf,”the string is;%s”,str); 重点
int sscanf(char *str, const char *format, …); 重点

fprintf 将格式化后的字符串写入到文件流 stream 中
sprintf 将格式化后的字符串写入到字符串 str 中

单个字符读写

#include <stdio.h>
int fgetc(FILE *stream);
int fputc(int c, FILE *stream);
int getc(FILE *stream);  等同于 fgetc(FILE* stream)
int putc(int c, FILE *stream);  等同于 fputc(int c, FILE* stream)
int getchar(void);  等同于 fgetc(stdin);
int putchar(int c);  等同于 fputc(int c, stdout);

字符串读写：

char *fgets(char *s, int size, FILE *stream);
int fputs(const char *s, FILE *stream);
int puts(const char *s);  等同于 fputs(const char *s,stdout);
char *gets(char *s);  等同于 fgets(const char *s, int size,
stdin);

文件定位：
文件定位指读取或设置文件当前读写点， 所有的通过文件指针读写数据的
函数， 都是从文件的当前读写点读写数据的。

#include <stdio.h>
int feof(FILE * stream); //通常的用法为 while(!feof(fp))
int fseek(FILE *stream, long offset, int whence);//设置当前读写点到偏移
whence 长度为 offset 处
long ftell(FILE *stream); //用来获得文件流当前的读写位置
void rewind(FILE *stream); //把文件流的读写位置移至文件开头
fseek(fp, 0, SEEK_SET);
feof 判断是否到达文件末尾的下一个（ 注意到达文件末尾之后还会做一次）
fseek 设置当前读写点到偏移 whence 长度为 offset 处， whence 可以是：
    SEEK_SET (文件开头 0)
    SEEK_CUR (文件当前位置 1)
    SEEK_END (文件末尾 2)
ftell 获取当前的读写点
rewind 将文件当前读写点移动到文件头

3. 目录相关操作

---

改变目录或文件的访问权限

#include <sys/stat.h>
int chmod(const char* path, mode_t mode);//mode 形如： 0777
path 参数指定的文件被修改为具有 mode 参数给出的访问权限。

获取、 改变当前目录：

#include <unistd.h> //头文件
char *getcwd(char *buf, size_t size); //获取当前目录， 相当于 pwd 命令
int chdir(const char *path); //修改当前目录， 即切换目录， 相当于 cd 命令

getcwd()函数，倘若参数 buf 为 NULL， getcwd()会依
参数 size 的大小自动配置内存(使用 malloc())， 如果参数 size 也为 0， 则 getcwd()会依工作目录绝对路径的字符串程度来决定所配置的内存大小
chdir()函数： 用来将当前的工作目录改变成以参数 path 所指的目录

创建和删除目录：
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int mkdir(const char *pathname, mode_t mode); //创建目录,mode 是目录权限
int rmdir(const char *pathname); //删除目录
也可用
 #include <unistd.h>
int unlink(const char *pathname);  来删除硬连接数

获取目录信息

#include <sys/types.h>
#include <dirent.h>
DIR *opendir(const char *name); //打开一个目录
struct dirent *readdir(DIR *dir); //读取目录的一项信息， 并返回该项信息的结构体指针
void rewinddir(DIR *dir); //重新定位到目录文件的头部
void seekdir(DIR *dir,off_t offset);//用来设置目录流目前的读取位置
off_t telldir(DIR *dir); //返回目录流当前的读取位置
int closedir(DIR *dir); //关闭目录文件

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
int stat(const char *pathname, struct stat *buf); 获取文件状态

读取目录信息的步骤为：
 1. 用 opendir 函数打开目录；
 2. 使用 readdir 函数迭代读取目录的内容， 如果已经读取到目录末尾， 又想重新开始读， 则可以使用 rewinddir 函数将文件指针重新定位到目录文件的起始位置；
 3. 用 closedir 函数关闭目录

1、opendir()用来打开参数 name 指定的目录， 并返回 DIR*形态的目录流
2、readdir()函数用来读取目录的信息， 并返回一个结构体指针， 该指针保存了目录的相关信息。 有错误发生或者读取到目录文件尾则返回 NULL；
3、seekdir()函数用来设置目录流目前的读取位置， 再调用 readdir()函数时， 便可以从此新位置开始读取。 参数 offset 代表距离目录文件开头的偏移量。
4、telldir()函数用来返回目录流当前的读取位置。

接下来看一下相关结构体的内容：
1、目录信息结构体：
struct dirent
{
    ino_t d_ino; /* inode number（ 此目录进入点的 inode） */
    off_t d_off; /* offset to the next dirent（ 目录开头到进入点的位移 */
    unsigned short d_reclen; /* length of this record（ 目录名的长度） */
    unsigned char d_type; /* type of file（ 所指的文件类型） */
    char d_name[256]; /* filename（ 文件名） */
};
2、文件状态及相关信息结构体：
struct stat {
    dev_t st_dev; /*如果是设备， 返回设备表述符， 否则为 0*/
    ino_t st_ino; /* i 节点号 */
    mode_t st_mode; /* 文件类型 */
    nlink_t st_nlink; /* 链接数 */
    uid_t st_uid; /* 属主 ID */
    gid_t st_gid; /* 组 ID */
    dev_t st_rdev; /* 设备类型*/
    off_t st_size; /* 文件大小， 字节表示 */
    blksize_t st_blksize; /* 块大小*/
    blkcnt_t st_blocks; /* 块数 */
    time_t st_atime; /* 最后访问时间*/
    time_t st_mtime; /* 最后修改时间*/
    time_t st_ctime; /* 最后权限修改时间 */
};

接下来举一个实例：  以树形结构的形式输出指定目录下面的所有文件
#include <unistd.h>
#include <stdio.h>
#include <dirent.h>
#include <string.h>
#include <sys/stat.h>
#include <stdlib.h>
void printdir(char *dir, int depth)
{
    DIR *dp = opendir(dir);
    if(NULL == dp)
    {
        fprintf(stderr,"cannot open directory: %s\n", dir);
        return;
    } 
    chdir(dir);
    struct dirent *entry;
    struct stat statbuf;
    while((entry = readdir(dp)) != NULL)
    {
        stat(entry->d_name,&statbuf);
        if(S_ISDIR(statbuf.st_mode))
        {
            if(strcmp(".",entry->d_name) == 0 || strcmp("..",entry->d_name) == 0)
            continue;
            printf("%*s%s/\n",depth,"",entry->d_name);
            printdir(entry->d_name,depth+4);
        }
        else
            printf("%*s%s\n",depth,"",entry->d_name);
            //printf(“%*s” ,4,” *” ); 该函数表示输出“___*” ,前面输出 3 个空格。
            //如果是 printf(“%*s” ,4,“**” );则表示输出“__**” ， 前面输出 2 个空格。
    } 
    chdir("..");
    closedir(dp);
}

int main(int argc, char* argv[])
{
    char *topdir, pwd[2]=".";
    if (argc < 2)
        topdir=pwd;
    else
        topdir=argv[1];
    printf("Directory scan of %s\n",topdir);
    printdir(topdir,0);
    printf("done.\n");
    exit(0);
}

4、标准输入/输出流

---

在进程一开始运行， 就自动打开了三个对应设备的文件， 它们是标准输入、 输出、 错误流， 分别用全局文件指针 stdin、 stdout、 stderr 表示， stdin 具有可读属性， 缺省情况下是指从键盘的读取输入， stdout 和 stderr 具有可写属性， 缺省情况下是指向屏幕输出数据。
示例：

#include <stdio.h>
#include <unistd.h>
int main()
{
    char szBuf[32];
    printf("Input string:"); //向屏幕输出一字符串
    fgets(szBuf,sizeof(szBuf),stdin);//从键盘读入一行字符串
    fprintf(stdout,"The string is:%s",szBuf);//向屏幕输出一行字符串
    return 0;
}

3、基于文件描述符的文件操作(非缓冲)

1、文件描述符简述
内核为每个进程维护一个已打开文件的记录表， 文件描述符是一个较小的正整数（ 0—1023） ， 它代表记录表的一项， 通过文件描述符和一组基于文件描述符的文件操作函数， 就可以实现对文件的读、 写、 创建、 删除等操作。 常用基于文件描述符的函数有 open（ 打开） 、 creat（ 创建） 、 close（ 关闭） 、 read（ 读取） 、 write（ 写入） 、 ftruncate（ 改变文件大小） 、 lseek（ 定位） 、 fsync（ 同步） 、 fstat（ 获取文件状态） 、 fchmod（ 权限） 、 flock（ 加锁） 、 fcntl（ 控制文件属性） 、
dup（ 复制） 、 dup2、 select 和 ioctl。 基于文件描述符的文件操作并非 ANSI C 的函数。

注：如果不清楚某个函数的具体实现形式， 可以通过下面的方式查询
man 函数名 查看该函数的帮助。

2、操作函数

**打开、 创建和关闭文件**
open 和 creat 都能打开和创建函数， 原型为

#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);//文件名 打开方式 权限
int creat(const char *pathname, mode_t mode); //文件名 权限 //现在已经不常用了
creat 函数等价于open(pathname,O_CREAT|O_TRUNC|O_WRONLY,mode);

open()函数出错时返回-1， 相关参数如下：flags 和 mode 都是一组掩码的合成值， flags 表示打开或创建的方式， mode 表示文件的访问权限。

close 用于文件的关闭：
int close(int fd);//fd 表示文件描述词,是先前由 open 或 creat 创建文件时的返回值。文件使用完毕后， 应该调用 close 关闭它， **一旦调用close， 则该进程对文件所加的锁全都被释放，并且使文件的打开引用计数减 1， 只有文件的打开引用计数变为 0 以后， 文件才会被真正的关闭。**

注：
LINUX 中基于文件描述符的 open 函数， 对于一个不存在的文件， 不能通过 O_WRONLY 的方式打开， 必须加上 O_CREAT 选项。

**读写文件、改变文件大小、文件定位、获取文件信息、以及文件描述符的复制**
1、读写文件

#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);//文件描述词 缓冲区 长度
ssize_t write(int fd, const void *buf, size_t count);
对于 read 和 write 函数， 出错返回-1， 读取完了之后， 返回 0， 其他情况返回读写的个数。

2、改变文件大小

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

3、文件定位

函数 lseek 将文件指针设定到相对于 whence， 偏移值为 offset 的位置
#include <sys/types.h>
#include <unistd.h>
off_t lseek(int fd, off_t offset, int whence);//fd 文件描述词

whence 可以是下面三个常量的一个
    SEEK_SET 从文件头开始计算
    SEEK_CUR 从当前指针开始计算
    SEEK_END 从文件尾开始计算

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

实例：
int main()
{
    int fd = open("c.txt", O_WRONLY | O_CREAT);
    lseek(fd, 1024, SEEK_SET);
    write(fd, "a", 1);
    close(fd);
    return 0;
}
**注：**
文件中的空洞并不需要在磁盘上分配磁盘块，在偏移之后，在写入一个数据，即可实现空洞，并且，使用lseek函数的偏移量大于当前文件大小是允许的。
可用  od  -c file  查看文件中的内容，-c是以字符方式打开的。
可使用  ls -ls file.hole  file.nohole   比较差别，第一个数据便是占用的磁盘块。

4、获取文件信息

可以通过 fstat 和 stat 函数获取文件信息， 调用完毕后， 文件信息被填充到结构体 struct stat
变量中， 函数原型为：
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

int stat(const char *file_name, struct stat *buf); //文件名 stat 结构体指针
int fstat(int fd, struct stat *buf); //文件描述词 stat 结构体指针，关于结构体，上面已经给出了。

5、文件描述符的复制

#include <unistd.h> //头文件包含

int dup(int oldfd);
int dup2(int oldfd, int newfd);

1、系统调用函数dup和dup2可以实现文件描述符的复制，经常用来重定向进程的
stdin(0),stdout(1),stderr(2)。
2、dup 返回新的文件描述符（**没有使用的文件描述符的最小编号**） 。 这个新的描述符是旧文件描述符的拷贝。**这意味着两个描述符共享同一个数据结构。**
3、dup2 允许调用者用一个有效描述符(oldfd)和目标描述符(newfd)， 函数成功返回时， 目标描述符将变成旧描述符的复制品， 此时两个文件描述符现在都指向同一个文件， 并且是函数第一个参数（ 也就是oldfd） 指向的文件。
4、文件描述符的复制是指用另外一个文件描述符指向同一个打开的文件， 它完全不同于直接给文件描述符变量赋值，若是赋值，两个文件描述符变量的值相同， 指向同一个打开的文件， **但是内核的文件打开引用计数还是为1**，所以 close掉任意一个都会导致文件立即关闭掉。
对于描述符的复制：内核的文件打开引用计数便会加一，关闭任意一个，通过另一个照样可以访问文件，只有都关闭，文件才正式关闭。
5、这两个接口常用来重定向，例如，进程默认的就打开了 0,1,2 表示标准输入， 标准输出， 标准错误输出。此时在关闭一个，比如 close(1);则表示关闭标准输出，当在调用fd2=dup(fd)时，当我们printf想要输出时，实际上是向fd2对应的文件输入内容了。
6、其dup2的原理也是一样的，eg：
        close(1);
        int fd1;
        printf("fd=%d\n",fd);//可以打印
        fd1=dup2(fd,STDOUT_FILENO);
        printf("fd1=%d\n",fd1);//这一句无法显示到屏幕上
        puts("you can't see me");

3、标准输入输出文件描述符

---

与标准的输入输出流对应， 在更底层的实现是用标准输入、 标准输出、 标准错误文件描述符表示的。它们分别用 STDIN_FILENO、STDOUT_FILENO 和 STDERR_FILENO 三个宏表示， 值分别是 0、 1、 2

标准输入文件描述符  STDIN_FILENO  0
标准输出文件描述符  STDOUT_FILENO  1
标准错误输出文件描述符  STDERR_FILENO  2

4、I/O 多路转接模型

在这种模型下， 如果请求的 I/O 操作阻塞， 且它不是真正阻塞 I/O，而是让其中的一个函数等待， 在这期间， I/O 还能进行其他操作。

5、文件共享时，一个进程内核为其维护的数据结构图—3张表

linux并没有采用v节点而是才用的是与文件相关的i节点，与文件无关的i节点

dup之后的内核数据结构