前言：
由操作系统实现并提供给外部应用程序的编程接口。(Application Programming Interface,API)。系统调用就是应用程序同系统之间数据交互的桥梁。
一、open/close函数
1.open函数：
（1）int open(char *pathname, int flags) #include
参数：
pathname: 欲打开的文件路径名
flags：文件打开方式： #include
O_RDONLY|O_WRONLY|O_RDWR O_CREAT|O_APPEND|O_TRUNC|O_EXCL|O_NONBLOCK ....
返回值：
成功： 打开文件所得到对应的 文件描述符（整数）
失败： -1， 设置errno
语法 open()方法语法格式如下： os.open(file, flags[, mode]); 参数 file – 要打开的文件 flags – 该参数可以是以下选项，多个使用 “|” 隔开： O_RDONLY: 以只读的方式打开 O_WRONLY: 以只写的方式打开 O_RDWR : 以读写的方式打开 O_NONBLOCK: 打开时不阻塞 O_APPEND: 以追加的方式打开 O_CREAT: 创建并打开一个新文件 O_TRUNC: 打开一个文件并截断它的长度为零（必须有写权限） O_EXCL: 如果指定的文件存在，返回错误 O_SHLOCK: 自动获取共享锁 O_EXLOCK: 自动获取独立锁 O_DIRECT: 消除或减少缓存效果 O_FSYNC : 同步写入 O_NOFOLLOW: 不追踪软链接 1）PROT_READ：表示内存段内的内容可写； 2）PROT_WRITE：表示内存段内的内容可读； 3）PROT_EXEC：表示内存段中的内容可执行； 4）PROT_NONE：表示内存段中的内容根本没法访问。
（2）int open(char *pathname, int flags， mode_t mode) 123 775
参数：
pathname: 欲打开的文件路径名
flags：文件打开方式：
O_RDONLY|O_WRONLY|O_RDWR O_CREAT|O_APPEND|O_TRUNC|O_EXCL|O_NONBLOCK ....
mode: 参数3使用的前提， 参2指定了 O_CREAT。
取值8进制数，用来描述文件的 访问权限。 rwx 0664
创建文件最终权限 = mode & ~umask
返回值：
成功： 打开文件所得到对应的 文件描述符（整数）
失败： -1， 设置errno
2.close函数：
int close(int fd);
3.错误处理函数：
与 errno 相关。
printf("xxx error: %d\n", errno);
char *strerror(int errnum); printf("xxx error: %s\n", strerror(errno));
void perror(const char *s); perror("open error");
二、read/write函数：
1.read函数：
ssize_t read(int fd, void *buf, size_t count);
参数：
fd： 文件描述符
buf： 存数据的缓冲区
count：缓冲区大小
返回值：
0： 读到文件末尾。
成功； > 0 读到的字节数。
失败： -1， 设置 errno
-1： 并且 errno = EAGIN 或 EWOULDBLOCK, 说明不是read失败，而是read在以非阻塞方式读一个设备文件（网络文件），并且文件无数据。
2.write函数：
ssize_t write(int fd, const void *buf, size_t count);
参数：
fd： 文件描述符
buf： 待写出数据的缓冲区
count：数据大小
返回值：
成功； 写入的字节数。
失败： -1， 设置 errno
示例：
用read和write函数实现cp操作（将open.c文件中的代码复制到open2.c中）
1 #include <unistd.h> 2 #include <fcntl.h> 3 #include <stdlib.h> 4 #include <pthread.h> 5 #include <string.h> 6 #include <stdio.h> 7 8 int main(int argc,char *argv[]) 9 { 10 char buf[1024]; 11 12 int n = 0; 13 14 int fd1 = open(argv[1],O_RDONLY); //read 15 if(fd1 == -1){ 16 perror("open argv1 error"); 17 exit(1); 18 } 19 20 int fd2 = open(argv[2],O_RDWR|O_CREAT|O_TRUNC,0664); 21 if(fd2 == -1){ 22 perror("open argv2 error"); 23 exit(1); 24 } 25 while((n = read(fd1,buf,1024))!=0){ 26 if(n < 0) 27 { 28 perror("read error"); 29 break; 30 } 31 write(fd2,buf,n); 32 } 33 34 close(fd1); 35 close(fd2); 36 } ~
系统调用和库函数比较
预读入缓输出
三、阻塞、非阻塞
阻塞、非阻塞： 是设备文件、网络文件的属性。
产生阻塞的场景： 读设备文件、读网络文件。（读常规文件无阻塞概念。）
/dev/tty --> 终端文件。
1.阻塞
1 #include <unistd.h> 2 #include <stdlib.h> 3 #include <stdio.h> 4 5 6 int main(void) 7 { 8 char buf[10]; 9 int n; 10 11 n = read(STDIN_FILENO, buf, 10); 12 // #define STDIN_FILENO 0 STDOUT_FILENO 1 STDERR_FILENO 2 13 if(n < 0){ 14 perror("read STDIN_FILENO"); 15 exit(1); 16 } 17 write(STDOUT_FILENO, buf, n); 18 19 return 0; 20 }
现在发生阻塞,一直处于读的状态 
当我们输入一串字符时，读操作结束，阻塞解除
那么阻塞是谁的特性？是read/write的吗？
答案当然不是了，应该是文件的属性，也就是设备文件或者网络文件
2.改变阻塞特性
open("/dev/tty", O_ RDWR|O_NONBLOCK) --- 设置 /dev/tty 非阻塞状态。(默认为阻塞状态)
3.非阻塞
1 #include <unistd.h> 2 #include <fcntl.h> 3 #include <errno.h> 4 #include <stdio.h> 5 #include <stdlib.h> 6 #include <string.h> 7 8 int main(void) 9 { 10 char buf[10]; 11 int fd, n; 12 13 fd = open("/dev/tty", O_RDONLY|O_NONBLOCK); 14 if (fd < 0) { 15 perror("open /dev/tty"); 16 exit(1); 17 } 18 19 tryagain: 20 21 n = read(fd, buf, 10); 22 if (n < 0) { 23 if (errno != EAGAIN) { // if(errno != EWOULDBLOCK) 24 perror("read /dev/tty"); 25 exit(1); 26 } else { 27 write(STDOUT_FILENO, "try again\n", strlen("try again\n")); 28 sleep(2); 29 goto tryagain; 30 } 31 } 32 33 write(STDOUT_FILENO, buf, n); 34 close(fd); 35 36 return 0; 37 }
4.设置非阻塞后的循环停止时间
1 #include <unistd.h> 2 #include <fcntl.h> 3 #include <stdlib.h> 4 #include <stdio.h> 5 #include <errno.h> 6 #include <string.h> 7 8 #define MSG_TRY "try again\n" 9 #define MSG_TIMEOUT "time out\n" 10 11 int main(void) 12 { 13 char buf[10]; 14 int fd, n, i; 15 16 fd = open("/dev/tty", O_RDONLY|O_NONBLOCK); 17 if(fd < 0){ 18 perror("open /dev/tty"); 19 exit(1); 20 } 21 printf("open /dev/tty ok... %d\n", fd); 22 23 for (i = 0; i < 5; i++){ 24 n = read(fd, buf, 10); 25 if (n > 0) { //说明读到了东西 26 break; 27 } 28 if (errno != EAGAIN) { //EWOULDBLOCK 29 perror("read /dev/tty"); 30 exit(1); 31 } else { 32 write(STDOUT_FILENO, MSG_TRY, strlen(MSG_TRY)); 33 sleep(2); 34 } 35 } 36 37 if (i == 5) { 38 write(STDOUT_FILENO, MSG_TIMEOUT, strlen(MSG_TIMEOUT)); 39 } else { 40 write(STDOUT_FILENO, buf, n); 41 } 42 43 close(fd); 44 45 return 0; 46 }
四、文件描述符：
PCB进程控制块： 本质是结构体。
成员：文件描述符表。
文件描述符：0/1/2/3/4........../1023 表中可用的最小的。
0 - STDIN_FILENO
1 - STDOUT_FILENO
2 - STDERR_FILENO
五、fcntl函数：
改变一个【己经打开】的文件的访问控制属性。
重点掌握两个参数的使用，F_GETFL 和 F_SETFL。
【fcntl.c】
int (int fd, int cmd, ...)
int flgs = fcntl(fd, F_GETFL);
flgs |= O_NONBLOCK
fcntl(fd, F_SETFL, flgs);
获取文件状态： F_GETFL
设置文件状态： F_SETFL
1 #include <unistd.h> 2 #include <fcntl.h> 3 #include <errno.h> 4 #include <stdio.h> 5 #include <stdlib.h> 6 #include <string.h> 7 8 #define MSG_TRY "try again\n" 9 10 int main(void) 11 { 12 char buf[10]; 13 int flags, n; 14 15 flags = fcntl(STDIN_FILENO, F_GETFL); //获取stdin属性信息 16 if(flags == -1){ 17 perror("fcntl error"); 18 exit(1); 19 } 20 flags |= O_NONBLOCK; 21 int ret = fcntl(STDIN_FILENO, F_SETFL, flags); 22 if(ret == -1){ 23 perror("fcntl error"); 24 exit(1); 25 } 26 27 tryagain: 28 n = read(STDIN_FILENO, buf, 10); 29 if(n < 0){ 30 if(errno != EAGAIN){ 31 perror("read /dev/tty"); 32 exit(1); 33 } 34 sleep(3); 35 write(STDOUT_FILENO, MSG_TRY, strlen(MSG_TRY)); 36 goto tryagain; 37 } 38 write(STDOUT_FILENO, buf, n); 39 40 return 0; 41 }
六、lseek函数：
lseek函数：
off_t lseek(int fd, off_t offset, int whence);
参数：
fd： 文件描述符
offset： 偏移量
whence：起始偏移位置： SEEK_SET/SEEK_CUR/SEEK_END
返回值：
成功：较起始位置偏移量
失败：-1 errno
应用场景：
1. 文件的“读”、“写”使用同一偏移位置。
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <fcntl.h> int main(void) { int fd, n; char msg[] = "It's a test for lseek\n"; char ch; fd = open("lseek.txt", O_RDWR|O_CREAT, 0644); if(fd < 0){ perror("open lseek.txt error"); exit(1); } write(fd, msg, strlen(msg)); //使用fd对打开的文件进行写操作，问价读写位置位于文件结尾处。 lseek(fd, 0, SEEK_SET); //修改文件读写指针位置，位于文件开头。 注释该行会怎样呢？ while((n = read(fd, &ch, 1))){ if(n < 0){ perror("read error"); exit(1); } write(STDOUT_FILENO, &ch, n); //将文件内容按字节读出，写出到屏幕 } close(fd); return 0; }
2. 使用lseek获取文件大小
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <fcntl.h> int main(int argc,char *argv[]) { int fd; fd = open(argv[1],O_RDWR); if(fd < -1){ perror("open lseek.txt error"); exit(1); } int len = lseek(fd, 0, SEEK_END); if(len == -1){ perror("lseek error"); exit(1); } printf("len of msg = %d\n", len); close(fd); return 0; }
3. 使用lseek拓展文件大小：要想使文件大小真正拓展，必须引起IO操作。
使用 truncate 函数，直接拓展文件。 int ret = truncate("dict.cp", 250);
（1）扩展文件大小：
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <fcntl.h> int main(int argc,char *argv[]) { int fd; fd = open(argv[1],O_RDWR); if(fd < -1){ perror("open lseek.txt error"); exit(1); } int len = lseek(fd, 111, SEEK_END); if(len == -1){ perror("lseek error"); exit(1); } printf("len of msg = %d\n", len); close(fd); return 0; }
（2）扩展文件大小—引起IO操作：
#include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <fcntl.h> int main(void) { int fd; char buf[64]; int ret = 0; fd = open("./file.txt", O_RDONLY); if (fd == -1) { printf("open file error\n"); exit(1); } printf("---open ok---\n"); while((ret = read(fd, buf, sizeof(buf)))) { write(1, buf, ret); } close(fd); return 0; }
使用 truncate 函数，直接拓展文件
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <fcntl.h> int main(int argc,char *argv[]) { int ret = truncate("test.c",250); printf("ret = %d\n",ret); return 0; }
七、传入传出参数：
1.传入参数：
1. 指针作为函数参数。
2. 通常有const关键字修饰。
3. 指针指向有效区域， 在函数内部做读操作。
2.传出参数：
1. 指针作为函数参数。
2. 在函数调用之前，指针指向的空间可以无意义，但必须有效。
3. 在函数内部，做写操作。
4。函数调用结束后，充当函数返回值。
3.传入传出参数：
1. 指针作为函数参数。
2. 在函数调用之前，指针指向的空间有实际意义。
3. 在函数内部，先做读操作，后做写操作。
4. 函数调用结束后，充当函数返回值。
