10.标准IO和文件IO

1. 文件基础

1. 概念：一组相关数据的有序集合

2. 文件类型：

1. 常规文件r

2. 目录文件d

3. 字符串设备文件c

4. 块设备文件 b

5. 管道文件p

6. 套接字文件s

7. 符号链接文件l

3. 系统调用和库函数

内核显卡驱动

把数据扔给内核，内核提供接口

4. 标准I/O-流

1. FILE

1. 标准io用一个结构体类型来存放打开的文件相关信息

2. 标准I/O的所有操作都是围绕FILE来进行

2. 流(stream)

1. FILE又被称为流(stream)

2. 文本流/二进制流

1. windows

1. 二进制流:换行符<- -> '\n'

2. 文本流:换行符 <- -> '\r' '\n'

2. linux

1. 换行符<- -> '\n'

5. 流的缓冲类型

1. 全缓冲

1. 当流的缓冲区无数据或无空间时才执行实际I/O操作

2. 行缓冲

1. 当在输入和输出中遇到换行符('\n')时进行I/O操作

2. 当流和一个终端关联时，典型的行缓冲

3. 无缓冲

1. 数据直接写入文件，流不进行缓冲

6. 标准I/O-stdin,stdout,stderr

1. 标准I/O预定义3个流，程序运行时自动打开

1. 标准输入流 0 STDIN_FILENO stdin(linux系统定义好的结构体)

2. 标准输出流 1 STDOUT_FILENO stdout

3. 标准错误流 2 STDERR_FILENO stderr

4. stdin/stdout默认是行缓冲

7. 缓冲区实验(4097可以打印，因为超过缓冲区)printf遇到\n结束

8. 文件的打开和关闭

1. 打开就是占用资源

2. 关闭就是释放资源

3. 下列函数可用于打开一个标准I/O流：

FILE *fopen (const char *path,const char *mode);

成功时返回流指针，出错时返回NULL;所以使用fopen函数必须判断是否是空的

d.关闭文件 int fclose(FILE *stream);

fclose()调用成功返回0,失败返回EOF,并设置errno

流关闭时自动刷新缓存中的数据并释放缓冲区

当一个程序正常终止时，所有打开的流都会被关闭

流一旦关闭后就不能执行任何操作

fclose()函数入参stream必须保证非空，否则出现段错误。

9. 标准I/O读写

1. 读写单个字符

1. 字符输入：

1. int fgetc(FILE *stream);

2. int getc(FILE *stream); // 宏

3. int getchar(void);

4. 成功返回读取的字符，若到文件末尾或出错时返回EOF(-1)

5. getchar()等同于fgetc(stdin)

6. getc和fgetc区别是一个是宏一个是函数

7. 注意：函数返回值是int类型而不是char类型，主要是为了扩展返回值的范围。

8. 注意：stdin也是FILE*的指针，是系统定义好的，指向的是标准输入（键盘输入）

9. 打开文件后读取，是从文件开头开始读。读完一个后,读写指针会后移。读写注意文件位置

2. 字符输出:

1. int fputc(int c, FILE *stream)

2. int putc(int c, FILE *stream);

3. int putchar(int c);

4. 成功时返回写入的字符，出错时返回EOF

5. putchar(c)等同于fputc(c, stdout)

6. 注意：返回和输入都是int类型

7. 遇到Bad file descriptor 一般是读写模式用错

2. 按行读写文件

1. 按行输入

1. char *gets(char *s);//读取标准输入到缓冲区s

2. char *fgets(char *s, int size, FILE *stream);//遇到'\n'或已输入size-1个字符时返回，总时包含'\0'

3. 成功时返回s，到文件末尾出错时返回NULL

4. 注意事项：gets函数已经被淘汰，因为会导致缓冲区溢出，fgets函数第二个参数，输入的数据超出size,size-1个字符会保存到缓冲区，最后添加'\0'，如果输入数据少于size-1，后面会添加换行符

2. 按行输出

1. int puts(const char *s);

2. int fputs(const char *s, FILE *stream);

3. 成功时返回非负整数，出错时返回EOF

4. puts将缓冲区s中的字符串输出到stdout,并追加\n

5. fputs将缓冲区s中的字符串输出到stream，不追加\n

3. 二进制读写

1. 文本文件和二进制的区别：存储格式不同（文本文件只能存储文本），除了文本文件都是二进制文件

2. 计算机内码概念

3. 下列函数用来从流中读写若干个对象

1. size_t fread(void *ptr, size_t size, size_t n, FILE *fp);//ptr读的内容，size一次读取的块大小，n是读取的个数，fp要读的文件指针

2. size_t fwrite(const void *ptr, size_t size, size_t n, FILE *fp);// 同读，fp要写的文件指针

3. 成功返回读写的对象个数，出错时返回EOF。既可以读写文本文件，也可以读写数据文件，效率高。

4. 注意事项：文件写完后，文件指针指向文件末尾，如果这时候读，读不出来内容。

5. 解决办法：移动指针到文件头（后面讲解）：关闭文件，重新打开

10. 文件流的刷新和定位

1. 刷新流int fflush(FILE *fp);

1. 成功时返回0，出错时返回EOF

2. 将流缓冲区中的数据写入实际的文件

3. linux下只能刷新输出缓冲区，输入缓冲区丢弃

4. 如果输出到屏幕使用fflush(stdout)/fflush(fp)

2. 定位流-ftell/fseek/rewind

1. long ftell(FILE *stream);

1. 成功时返回流当前读写位置，出错时返回EOF

2. long fseek(FILE *stream,long offset, int whence);

1. 定位一个流，成功时返回0，出错时返回EOF

3. void rewind(FILE *stream);

1. whence参数：SEEK_SET/SEEK_CUR/SEEK_END(这三个函数只适用2G以下的文件)

1. SEEK_SET从据头文件开头offset位移量为新的读写位置

2. SEEK_CUR以目前的读写位置往后增加offset个位移量

3. SEEK_END将读写位置指向文件尾后再增加offset个位移量

4. offset参数：偏移量，可正可负

5. 打开a模式fseek无效，rewind(fp)相当于fseek(fp,0,SEEK_SET);

6. rewind()将流定位到文件开始位置

7. 读写流时，当前读写位置自动后移

8. 示例一（在文件末尾追加字符't'）

1. FILE *fp = fopen("test.txt", "r+");

2. fseek(fp, 0, SEEK_END);

3. fputs('t', fp);

11. 格式化输入和输出

1. sprintf

1. int sprintf(char *s, const char *fmt,...);

2. fprintf

1. int fprintf(FILE *stream, const char *fmt,...);

3. 成功时返回输出的字符个数，出错时返回EOF,使用起来很方便，强烈推荐

4. fscanf

1. int fscanf(FILE *stream, const char *format, ...);

5. sscanf

1. int sscanf(const char *str, const char * format,...);

12. 什么是文件I/O?

1. posix（可移植操作系统接口）定义的一组函数

2. 文件IO不提供缓存冲机制，每次读写操作都引起系统调用

3. 核心概念是文件描述符

1. 每个打开的文件都对应一个文件描述符。

2. 文件描述符是一个非负整数。Linux为程序中每个打开的文件分配一个文件描述符。(是0-1023的数字，表示文件)

3. 文件描述符从0开始分配，依次递增

4. 文件IO操作通过文件描述符来完成

5. 0:标准输入 stdin 1:标准输出 stdout 2:标准错误 stderr

4. 访问各种类型文件，Linux下，标准IO基于文件IO实现

	标准IO	文件IO(低级IO)
打开	fopen,freopen,fdopen	open
关闭	fclose	close
读	getc,fgetc,ggetchar,fgets,gets,fread	read
写	putc,fputc,putchar,fputs,puts,fwrite	write

5. open函数用来创建或打开一个文件

1. #include<fcntl.h>

2. int open(const char *pathname, int flags);//不创建文件

3. int open(const char *pathname,int flags, mode_t mode);//创建文件，但是不能创建设备文件

1. pathname文件名，可包括路径名

2. flags:

1. O_RDONLY:只读方式打开文件

2. O_WRONLY:可写方式打开文件

3. O_RDWR:读写方式打开文件

4. O_CREAT:如果该文件不存在，就创建一个新的文件，并用第三的参数为其设置权限

5. O_EXECL:如果用O_CREATE时文件存在，则返回错误信息。这一参数可测试文件是否存在。

6. O_NOCTTY:使用本参数时，如文件为终端，那么终端不可作为调用open()系统调用的哪个进程控制终端

7. O_TRUNC:如果文件已经存在，那么打开文件时先删除文件中的原有数据

8. O_APPEND:以添加方式打开文件，所以对文件的些操作都在文件的末尾进行

r	O_RDONLY
r+	O_RDWR
w	O_WRONLY|O_CREAT|O_TRUNO,0664
w+	O_RDWR|O_CREAT|O_TRUNC,0664
a	O_WRONLY|O_CREAT|O_APPEND,0664
a+	O_RDWR|O_CREAT|O_APPEND,0664

3. mode:被打开文件的存取权限，为8进制表示法。

4. 成功时返回文件描述符，出错时返回EOF

5. 打开文件时使用两个参数

6. 创建文件时第三个参数指定新文件的权限，（只有在建立新文件时有效）此外真正建文件时的权限会受到umask值影响，实际权限是mode-umask

1. umask:用来设定文件或目录的初始权限

1. 文件和目录的真正初始权限

2. 文件或目录的初始权限=文件或目录的最大默认权限-umask

7. 可以打开设备文件，但是不能创建设备文件（创建设备文件mknode驱动部分会讲）

6. close函数用来关闭一个打开的文件：

1. #include<unistd.h>

2. int close(int fd);

3. 成功时返回0；出错时返回EOF(-1)

4. 程序结束时自动关闭所有打开的文件

5. 文件关闭后，文件描述符不再代表文件

7. 文件IO的读写定位

1. 读取文件

1. #include<unistd.h>

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

1. 成功时返回实际读取的字节数，出错时返回EOF

2. 读到文件末尾时返回0

3. buf是接收数据的缓冲区

4. count不应超过buf大小

2. 写入文件

1. #include <unistd.h>

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

1. 成功时返回实际读取的字节数，出错时返回EOF

2. buf是接收数据的缓冲区

3. count不应超过buf大小

3. 定位文件

1. #include<unistd.h>

2. off_t lseek(int fd, off_t offset, intt whence);

1. 成功时返回当前文件读写位置；出错时返回EOF

2. 参数offset和whence同fseek相同

13. 目录操作和库的使用

1. 访问目录

1. opendir函数用来打开一个目录文件

1. #include<dirent.h>

2. DIR *opendir(const char *name);

3. DIR *fdopendir(int fd);使用文件描述符，要配合open函数使用

1. DIR是用来描述一个打开的目录文件的结构体类型

2. 成功时返回目录流指针，出错时返回NULL

2. readdir函数用来读取目录流中的内容

1. #include<dirent.h>

2. struct dirent *readdir(DIR *dirp);

1. struct dirent是用来描述目录流中一个目录项的结构体类型

2. 包含成员char d_name[256] 参考帮助文档

3. 成功时返回目录流dirp中下一个目录项

4. 出错或到末尾时返回NULL

3. closefir函数用来关闭一个目录文件

1. #include<dirent.h>

2. int closedir(DIR *dirp);

1. 成功时返回0，出错时返回EOF

2. 修改文件访问权限-chomod/fchmod

1. #include<sys/stat.h>

2. int chmod(const char *path, mode_t mode);

3. int fchmod(int fd, mode_t mode);

1. 成功时返回0，出错返回EOF

2. root和文件所有者能修改文件的访问权限：chmod("test.txt", 0666);

3. 获取文件属性-stat/lstat/fstat

1. #include<sys/stat.h>

2. int stat(const char *path,struct stat*buf);

3. int lstat(const char *path, struct stat *buf);

4. int fstat(int fd,struct stat *buf);

5. 成功时返回0，出错时返回eof

6. 如果path是符合链接stat获取的是目标文件的属性，而lstat获取的是连接文件的属性

7. struct stat结构体s是存放文件属性的结构体类型

1. mode_t st_mode; 类型和访问权限

2. uid_t st_uid; 所有者id

3. uid_t st_gid;用户组id

4. off_t st_size; 文件大小

5. time_t st_mtime;最后修改时间

6. struct stat{

dev_t st_dev;//文件的设备编号

ino_t st_ino; // 节点

mode_t st_mode; //文件的类型和存取的权限

nlink_t st_nlink; // 连到该文件的硬链接数目，刚建立的文件值为1

uid_t st_uid; // 用户id

gid_t st_gid; // 组ID

dev_t st_rdev; // (设备类型）若此文件为设备文件，则为其设备编号

off_t st_size; // 文件字节数（文件大小）

unsigned long st_blksize; // 块大小（文件系统的I/O缓冲区大小)

unsigned long st_blocks; // 块数

time_t st_atime;//最后一次访问时间

time_t st_mtime; //最后一次修改时间

time_t st_ctime; // 最后一次改变时间（指属性）

}

8. 文件类型-通过系统提供的宏判断文件类型：

1. S_IFMT 0170000 文件类型的位遮罩

2. S_ISREG(st_mode) 0100000 是否常规文件

3. S_ISDIR(st_mode) 0040000 是否目录

4. S_ISCHR(st_mode) 0020000 是否字符设备

5. S_ISBLK(st_mode) 0060000 是否块设备

6. S_ISFIFO(st_mode) 0010000 是否FIFO文件

7. S_ISLNK(st_mode) 0120000 是否链接文件

8. S_ISSOCK(st_mode) 0140000 是否SOCKET文件

9. 文件访问权限-通过系统提供的宏来获取文件访问权限

1. S_IRUSR 00400 bit:8 所有者有读权限

2. S_IWUSR 00200 7 所有者拥有写权限

3. S_IXUSR 00100 6 所有者拥有执行权限

4. S_IRGRP 00040 5 群组拥有读权限

5. S_IWGRP 00020 4 群组拥有写权限

6. S_IXGRP 00010 3 群组拥有执行权限

7. S_IROTH 00004 2 其他用户拥有读权限

8. S_IWOTH 00002 1 其他用户拥有写权限

9. S_IXOTH 00001 0 其他用户拥有执行权限

14. 静态库和动态库使用

1. 库的概念

1. 库是一个二进制文件，包含的代码可被程序调用：

1. 标准c库

2. 数学库

3. 线程库...

2. 库有源码，可下载后编译；也可以直接安装二进制包

1. /lib

2. /usr/lib

3. 库是事先编译好的，可以复用的代码。在os上运行的程序基本上都要使用库。使用库 提高开发效率。Windows和Linux下库文件格式不兼容。Linux下包含静态库和共享库。

2. 静态库特点

1. 编译（链接）时把静态库中相关代码复制到可执行文件中

2. 程序中已经包含代码，运行时不再需要静态库。

3. 程序运行时无需加载库，运行速度更快

4. 占用更多磁盘和内存空间。静态库升级后

5. 程序需要重新编译链接

3. 静态库创建

1. 命令：ar rsv libhello.a hello.o (假如hello.o文件) /// 用lib开头，静态库是.a

1. ar参数：

1. c禁止在创建库时产生的正常消息

2. r 如果指定的文件已经存在于库中，则替换它

3. s 无论ar命令是否修改了库内容都强制重新生成库符号表

4. v将建立新库的详细的逐个文件的描述写至标准输出

5. q将指定的文件添加到库的末尾

6. t将库的目录写至标准输出

2. 步骤：

1. 编写库文件代码，编译为.o文件

2. ar 命令 libxxx.a xxx.o

3. 静态库要以lib开头，后缀名为.a

4. 没有main函数的.c文件不能生成可执行文件

4. 链接静态库

1. 编译test.c并链接静态库libhello.a

1. gcc -o test test.c -L. -lhello(不用libhello直接小写L+hello)

2. ./test

5. 动态库（共享库）特点

1. 编译（链接）时仅记录用到哪个共享库中的哪个符号，不复制共享库中相关代码

2. 程序中不包含库中代码，尺寸小

3. 多个程序可共享同一个库

4. 程序运行时需要加载库

5. 库加载方便，无需重新编译程序

6. 使用更加广泛

6. 动态库生成步骤

1. 生成位置无关的代码目标文件

1. 使用gcc -c -fPID xxx.c xxx.c ....

2. 生成动态库

1. gcc -shared -o libxxx.so xxx.o xxx.o ...

3. 链接动态库

1. gcc -o test test.c -L. -lxxxx

7. 如何找到共享库

1. 为了让系统能找到要加载的共享库，有三种方法：

1. 把库拷贝到/usr/lib和/lib下

2. 在LD_LIBARY_PATH环境变量中添加库所在路径

3. 添加/etc/ld.so.conf.d/*.conf文件，执行ldconfig刷新

1. ~/.bashrc文件里面

2. source ~/.bashrc生效

4. ldd查看可执行文件的动态库