系统调用（系统API）
就是操作系统提供的一些功能供程序员使用，这些系统调用已经被封装成了C函数的形式，但它们不是标准C
的一部分
一般应用程序运行在用户态[0,3g),使用系统调用时进入内核态进行系统调用(3,4g) 常用的标准库函数大部分都
在用户态，底层偶尔也会调用系统，但是少部分在内核态例如malloc
系统调用的代码时内核的一部分，其外部接口以共享库函数的形式提供（linux-gate.so\ld-linux.so），并且这些
接口的实现利用软中断进入到内核执行其真正的系统调用代码。
time ./a.out 测试程序运行时间
real 0m0.004s 总运行时间
user 0m0.000s 用户态的执行时间
sys 0m0.000s 内核态的执行时间
发现总时间不一样，消耗在两状态切换浪费时间，输入输出浪费时间，CPU很忙没及时处理
总运行时间 = 用户态时间+内核态时间+切换时间+IO时间+CPU时间
一切皆文件
UNIX/Linux操作系统把设备和服务都抽象成了文件形式，并提供了一套简单而统一的接口，这部分接口就是文件IO，
也就是说UNIX/Linux系统中任何对象都可以当做某种特殊的文件，以文件的形式访问
Linux文件的分类
普通文件 - 包括纯文本文件，二进制文件，压缩文件
目录文件 d（direction）
块设备文件 b（block） 保存大块数据的设备
字符设备文件 c（char） 类似键盘，鼠标
管道文件 p（pipeline）
链接文件 l（link）
Socket文件 S 通常用于网络数据连接
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int open(const char *pathname, int flags);
功能：打开文件
pathname：文件路径
flags：文件打开方式
O_RDONLY 读
O_WRONLY 写
O_RDWR 读写
O_CREAT 文件不存在创建
O_EXCL 如果文件存在创建失败
O_NOCTTY 非阻塞
O_TRUNC 文件存在清空打开
O_APPEND 追加
O_SYNC 同步，写入数据等待数据被写入
O_ASYNC 异步，当文件进行读写时，向进程发送型号SIGIO
返回值：文件描述符，类型基于标准库FILE*，代表了一个打开的文件
int open(const char *pathname, int flags, mode_t mode);
功能：创建文件
flags：
S_IRWXU 00700 user (file owner) has read, write and execute permission
S_IRUSR 00400 user has read permission
S_IWUSR 00200 user has write permission
S_IXUSR 00100 user has execute permission
S_IRWXG 00070 group has read, write and execute permission
S_IRGRP 00040 group has read permission
S_IWGRP 00020 group has write permission
S_IXGRP 00010 group has execute permission
S_IRWXO 00007 others have read, write and execute permission
S_IROTH 00004 others have read permission
S_IWOTH 00002 others have write permission
S_IXOTH 00001 others have execute permission
rw-r--r-- 0644
返回值：成功非0，失败-1
int creat(const char *pathname, mode_t mode);
练习：测试fopen的打开方式与open的哪些参数相对应(strace ./a.out 追踪文件查看信息)
w: O_WRONLY|O_CREAT|O_TRUNC, 0666
w+: O_RDWR|O_CREAT|O_TRUNC, 0666
r: O_RDONLY
r+: O_RDWR
a: O_WRONLY|O_CREAT|O_APPEND, 0666
a+: O_RDWR|O_CREAT|O_APPEND, 0666
#include <unistd.h>
ssize_t write(int fd, const void *buf, size_t count);
功能：把内存中的数据写入到文件中
fd：文件描述符，也就是open的返回值
*buf：待写入的内存数据的首地址
count：要写入的字节数
返回值：返回实际写入的字节数
ssize_t read(int fd, void *buf, size_t count);
功能：从文件中读取数据到内存
fd：文件描述符，也就是open的返回值
*buf：存储数据的首地址
count：要读取的字节数
返回值：实际读取到的字节数
int close(int fd);
功能：关闭文件
练习2：分别使用标准IO（fopen/fread/fwrite）和系统IO写入100w个整数 到文件中 测试谁更快
标准IO：fwrite
ubuntu@~/classwork/UNIX/unix day03$ time ./a.out
real 0m0.024s
user 0m0.012s
sys 0m0.004s
系统IO：write
ubuntu@~/classwork/UNIX/unix day03$ time ./a.out
real 0m0.804s
user 0m0.004s
sys 0m0.780s
惊了呀！青出于蓝，使用标准IO比系统IO更快，原因就是标准IO有缓冲区机制在！！！，在写入数据时
不会直接使用系统IO，而是利用缓冲区进行存储，等到缓冲区填满后再调用系统IO！所以大大降低了写入的次数
导致时间大幅降低，如果给系统IO手动添加一个更大的缓冲区时，它的速度会比IO更快
ubuntu@~/classwork/UNIX/unix day03$ time ./a.out
real 0m0.004s
user 0m0.000s
sys 0m0.000s
这是手动添加8k缓冲区的效果 果然很快
随机读写
每个打开文件都有一个记录读写位置的指针，也叫文件位置指针，对文件的读写操作都是从该指针向
的位置进行的，并且位置指针会随着读写操作而增加移动。
一个打开的文件，位置指针就会指向头文件开头，如果使用O_APPEND,则会在末尾。
如果想要随机读写文件中任何位置的数据，需要调整文件位置指针
#include <stdio.h>
int fseek(FILE *stream, long offset, int whence);
标准IO
#include <sys/types.h>
#include <unistd.h>
off_t lseek(int fd, off_t offset, int whence);
系统IO
fd:文件描述符
offset：偏移值
whence：基础位置
SEEK_SET The offset is set to offset bytes.
SEEK_CUR The offset is set to its current location plus offset bytes.
SEEK_END The offset is set to the size of the file plus offset bytes.
返回值：返回调整后文件位置指针所处的位置
在越过文件末尾继续写入数据，相隔一段位置将形式空洞，空洞也一样会被计算到文件大小中，
但是不占有磁盘空间
系统IO读写文本文件
由于系统IO是没有办法使用fscanf/fprintf函数的，因此不能直接读写文本文件
写文本文件: 把要写入的对象 通过sprintf 转换为字符串，然后再写入到文件中。
读文本文件:先按照字符串形式先读取到字符串变量中，然后在使用 sscanf 来提取出对应的数据使用
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<stdlib.h>
typedef struct Student
{
char name[20];
char sex;
short age;
int sid;
}Student;
int main(int argc,const char* argv[])
{
/*int fd = open("stu.txt",O_RDWR|O_CREAT,0644);
if(fd < 0) return -1;
Student stu = {"Amo",'m',20,1000};
for(int i=0;i<10;i++)
{
stu.sid = 1000+i;
char str[255] = {};
sprintf(str,"%s %c %hd %d\n",stu.name,stu.sex,stu.age,stu.sid);
printf("str:%s\n",str);
write(fd,str,strlen(str));
}
close(fd);
*/
int fd = open("stu.txt",O_RDONLY);
if(fd < 0) return -1;
char* buf = malloc(4096);
char* temp = buf;
read(fd,buf,4096);
while(strstr(buf,"\n"))
{
Student stu = {};
sscanf(buf,"%s %c %hd %d\n",stu.name,&stu.sex,&stu.age,&stu.sid);
printf("str:%s %c %hd %d\n",stu.name,stu.sex,stu.age,stu.sid);
buf = strstr(buf,"\n")+1;
}
free(temp);
close(fd);
temp = NULL;
buf = NULL;
}
文件描述符
1、非负整数，代表一个打开的文件
2、由系统调用而返回，可以被内核空间引用
3、它代表着一个内核对象（相当于FILE对象），因为内核不能暴露它的地址，因此不能返回一个对象指针
4、内核中有一张记录所有打开的文件对象，文件描述符就是访问这张表的下标，因此文件描述符也叫做
句柄，也就是访问指针的凭证。
内核中有三个默认打开的文件描述符：
句柄 功能
0 标准输入 stdin
1 标准输出 stdout
2 标准错误 stderr
文件描述符的复制：
#include <unistd.h>
int dup(int oldfd);
功能：复制一个已经打开的文件描述符
返回值：返回一个当前没有使用过的最小的文件描述符
int dup2(int oldfd, int newfd);
功能：复制一个指定的文件描述符
newfd：想要复制成的文件描述符，如果打开冲突，则会先关闭再复制
注意：复制成功后，相当于两个文件描述符同时对应一个打开的文件
练习3：使用系统IO来实现一个带覆盖提醒的cp命令
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
int main(int argc,const char* argv[])
{
if(3 != argc)
{
printf("User: ./cp src dest");
return 0;
}
int src = open(argv[1],O_RDONLY);
if(0 > src)
{
printf("源文件不存在，请检查\n");
return 0;
}
int dest = open(argv[2],O_WRONLY|O_EXCL|O_CREAT,0644);
if(0 > dest)
{
printf("目标文件已存在，是否覆盖(Y/y)\n");
char cmd = getchar();
if('y' != cmd && 'Y' != cmd)
{
printf("停止拷贝了！\n");
close(src);
return 0;
}
else
{
printf("覆盖目标文件！\n");
dest = open(argv[2],O_WRONLY|O_TRUNC);
}
}
int ret = 0;
char buf[4096] = {};
while(ret = read(src,buf,sizeof(buf)))
{
write(dest,buf,ret);
}
close(src);
close(dest);
return 0;
}