基础IO+系统文件IO+文件描述符+文件描述符分配规则
自我名言 :只有努力,才能追逐梦想,只有努力,才不会欺骗自己。
喜欢的点赞,收藏,关注一下把!
1.重新谈论文件
根据前面所学知识,我们也了解一些文件的相关知识:
1.空文件,也要在磁盘占据空间
2.文件=文件内容+文件属性
3.文件操作=对内容+对属性 or 对内容和属性
4.标定一个文件,必须使用:文件路径+文件名【唯一性】
5.如果没有指定对应的文件路径,默认是在当前路径(进程当前的路径),进行访问
6.当我们把fopen,fclose,fwrite,fread接口写完之后,代码编码之后,形成一个二进制可执行程序之后,但是没有运行,文件对应的操作有没有被执行?
其实并没有,对文件的操作,本质:进程对文件的操作!
7.一个文件如果没有被打开,可以直接进行文件访问吗?
不能,一个文件要被访问,必须先被打开。 那么被谁打开呢?
对文件的操作,是在进程中进行的,因此首先是用户进程,其次对文件操作的C接口是封装了系统调用接口,这部分是由OS操作的。
因此是由用户进程+OS共同进行的。
是不是所有文件都被打开呢?
不是,这里文件分成两类
a.被打开的文件
b.没有被打开的文件
上述这么多知识都是为了阐明一点:
文件操作的本质:进程+被打开文件的关系
2.重谈文件操作(C语言)
1.C,C++,Java,python...shell都有对文件操作的接口,但是接口都不一样
根据目前掌握的知识,了解文件在磁盘 里,而磁盘是 一个硬件 ,OS能访问硬件 ,因此所有人想访问磁盘都绕不过OS ,使用的是OS提供的接口 ,想访问的是磁盘上的文件,因此使用的是OS提供文件级别的系统调用接口 。所有语言访问文件接口五花八门,但是操作系统只有一个。
所以上层语言无论如何变化
a.库函数底层都必须调用系统调用接口
b.库函数可以千变万化,但是底层不变
为了降低学习成本------->学习不变的东西
2.1C文件接口
2.文件的操作(C语言)
在C的时候学过文件相关操作知识,这里不再详细说,对这块知识记得不清的可以参考这篇博客超详细C语言文件操作,学完对文件了解更进一步。
![](https://file.jishuzhan.net/article/1713040254266511361/b8c9e4eef8c3604bb33e2e9da223de80.webp)
fopen打开文件,必须要提供打开的方式。这里总结一下
r(读),w(写),
r+(读写,文件不存在报错),w+(读写,文件不存在创建),
a(append,追加),a+(在文件尾读写,文件不存在创建),
rb(读(二进制)),wb(写(二进制)),
rb+(读写(二进制),报错),wb+(读写(二进制),创建)
ab(二进制文件尾追加),ab+(二进制文件尾读写,创建)
写
c
1 #include<stdio.h>
2
3 int main()
4 {
5 //打开
6 FILE* fp=fopen("log.txt","w");
7 if(fp == NULL)
8 {
9 perror("fopen");
10 return 1;
11 }
12
13 //写
14 int cnt=5;
15 while(cnt)
16 {
17 fprintf(fp,"%s:%d\n","hello linux",cnt--);
18 }
19
20 //关闭
21 fclose(fp);
22 return 0;
23 }
读
c
1 #include<stdio.h>
2 #include<string.h>
3
4 int main()
5 {
6 //打开
7 // FILE* fp=fopen("log.txt","w");
8 FILE* fp=fopen("log.txt","r");
9 if(fp == NULL)
10 {
11 perror("fopen");
12 return 1;
13 }
14
15 // //写
16 // int cnt=5;
17 // while(cnt)
18 // {
19 // fprintf(fp,"%s:%d\n","hello linux",cnt--);
20 // }
21
22 //读
23 char buffer[64];
24 while(fgets(buffer,sizeof(buffer)-1,fp) != NULL)
25 {
26 buffer[strlen(buffer)-1]=0;
27 puts(buffer);
28 }
29
30 //关闭
31 fclose(fp);
32 return 0;
33 }
追加
c
1 #include<stdio.h>
2 #include<string.h>
3
4 int main()
5 {
6 //打开
7 // FILE* fp=fopen("log.txt","w");
8 // FILE* fp=fopen("log.txt","r");
9 FILE* fp=fopen("log.txt","a");
10 if(fp == NULL)
11 {
12 perror("fopen");
13 return 1;
14 }
15
16 //写
17 int cnt=5;
18 while(cnt)
19 {
20 fprintf(fp,"%s:%d\n","hello linux",cnt--);
21 }
22
23 // //读
24 // char buffer[64];
25 // while(fgets(buffer,sizeof(buffer)-1,fp) != NULL)
26 // {
27 // buffer[strlen(buffer)-1]=0;
28 // puts(buffer);
29 // }
30
31 //关闭
32 fclose(fp);
33 return 0;
34 }
以w方式单词的打开文件,C会自动清空内部数据
c
1 #include<stdio.h>
2 #include<string.h>
3
4 int main()
5 {
6 //打开
7 FILE* fp=fopen("log.txt","w");
8 // FILE* fp=fopen("log.txt","r");
9 // FILE* fp=fopen("log.txt","a");
10 if(fp == NULL)
11 {
12 perror("fopen");
13 return 1;
14 }
15
16 // //写
17 // int cnt=5;
18 // while(cnt)
19 // {
20 // fprintf(fp,"%s:%d\n","hello linux",cnt--);
21 // }
22
23 // //读
24 // char buffer[64];
25 // while(fgets(buffer,sizeof(buffer)-1,fp) != NULL)
26 // {
27 // buffer[strlen(buffer)-1]=0;
28 // puts(buffer);
29 // }
30
31 //关闭
32 fclose(fp);
33 return 0;
34 }
![](https://file.jishuzhan.net/article/1713040254266511361/49bf42af4d4387bf3f50ea2855340a3b.webp)
这些都是C语言给我提供的一些对文件操作的接口。现在来看看OS给我们提供的关于对文件操作的系统调用的接口。
3.系统文件IO
3.1open
![](https://file.jishuzhan.net/article/1713040254266511361/025480eb3dbc56cbb825976a8191373e.webp)
open有两个接口,首先来讲第二个接口
第一个参数:文件名
第三个参数:权限(如果创建一个文件,告诉系统该文件的权限是什么)
![](https://file.jishuzhan.net/article/1713040254266511361/a9304bde4a737b037149475eb32e369c.webp)
第二个参数:flags(是一个标记位,告诉系统以什么方式打开文件)
![](https://file.jishuzhan.net/article/1713040254266511361/b587f833218410a75fc6e195c288b74a.webp)
O_RDONLY(只读),O_WRONLY(只写),O_RDWR(读写)
flags有很多选项,这些选项是大写的,在我们印象中这样写都是宏。
C传标记位,一个int表示一个标记位,如果想传多个标记位怎么办呢?难道要传多个int吗?
显然这样处理不好。
正确解决方法:一个整数---->32个比特位---->通过比特位传递选项(一个比特位,一个选项,比特位位置不能重复)。
c
1 #include<stdio.h>
2 #include<string.h>
3
4 //每一个宏,对应的数值,只有一个比特位是1,彼此位置不能重叠
5 #define ONE (1<<0)
6 #define TWO (1<<1)
7 #define THERE (1<<2)
8 #define FOUR (1<<3)
9
10 void show(int flags)
11 {
12 if(flags & ONE) printf("one\n");
13 if(flags & TWO) printf("two\n");
14 if(flags & THERE) printf("there\n");
15 if(flags & FOUR) printf("four\n");
16 }
17
18 int main()
19 {
20
21 show(ONE);
22 printf("------------------\n");
23 show(ONE|TWO);
24 printf("------------------\n");
25 show(ONE|TWO|THERE);
26 printf("------------------\n");
27 show(ONE|TWO|THERE|FOUR);
28 printf("------------------\n");
29
30 return 0;
31 }
![](https://file.jishuzhan.net/article/1713040254266511361/9d9dcc99ffdb1f9ba56b532de871265a.webp)
返回值:文件描述符(成功),-1(失败)
![](https://file.jishuzhan.net/article/1713040254266511361/6d22184158cdf0234044661efce50927.webp)
c
#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
int main()
{
//打开
int fd=open("log.txt",O_WRONLY);
if(fd<0)
{
perror("open");
return 1;
}
//关闭
close(fd);
return 0;
}
![](https://file.jishuzhan.net/article/1713040254266511361/a0d0f5ed47959d5abacdffde38debc98.webp)
文件不存在,并不会自动创建。
这是因为我们调用C接口,是对底层的封装,然后让底层帮我们创建,但是现在我们直接用的就是底层,如果不给具体选项,是不会帮我们自动创建的。
c
#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
int main()
{
//打开
//O_CREAT 创建
int fd=open("log.txt",O_WRONLY|O_CREAT);
if(fd<0)
{
perror("open");
return 1;
}
//关闭
close(fd);
return 0;
}
![](https://file.jishuzhan.net/article/1713040254266511361/5c6c75e3ab72d43e10115490051d271e.webp)
虽然成功创建了文件,但是这个文件权限和我们用C接口创建文件的权限是不一样的,这个是上面所说的原因一样,现在用的是系统调用接口,需要直接告诉这个文件权限是什么。
cpp
#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
int main()
{
//打开
int fd=open("log.txt",O_WRONLY|O_CREAT,0666);
if(fd<0)
{
perror("open");
return 1;
}
//关闭
close(fd);
return 0;
}
![](https://file.jishuzhan.net/article/1713040254266511361/202f590cec37fdddcf67437503c7baa6.webp)
![](https://file.jishuzhan.net/article/1713040254266511361/8415903905aacf8bdca78b10038f6ffa.webp)
文件不存在,用的是有第三个参数的接口。
文件存在(已经有了权限),用的是没有第三个参数的接口。
这里可能有个疑问。我给新创建的文件权限设置是0666,为什么新创建的文件权限权限是0664呢?
文件最终权限=起始权限(0666)&(~umask(普通用户0002))
所以新创建的文件权限是0664
那我们就想新创建的文件权限就是我们设置的权限怎么办呢?
umask(0)
清掉系统默认的umask
c
#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
int main()
{
umask(0);
//打开
int fd=open("log.txt",O_WRONLY|O_CREAT,0666);
if(fd<0)
{
perror("open");
return 1;
}
//关闭
close(fd);
return 0;
}
![](https://file.jishuzhan.net/article/1713040254266511361/1afe34d6b03994bd886385b9f6d98a2e.webp)
我们手动清楚了系统默认的umask,为什么这里还是0002呢?
注意,我们改掉的是子进程的权限,并不影响shell(还是0002)。
3.2close
![](https://file.jishuzhan.net/article/1713040254266511361/1587f74a2d90cc6e1ea9a3e54c1a1f10.webp)
关闭文件。
参数就是文件描述符。
3.3write
![](https://file.jishuzhan.net/article/1713040254266511361/88e8d2fb345ee6fb8d1fc46a4317b0df.webp)
第一个参数:向那个文件里写
第二个参数:想写对应的缓冲区数据在哪里
为什么第二个参数用的是void呢?
语言层面把文件类型分为:1,文本文件 。2,二进制文件。
但是操作系统一律认为都是二进制文件,所以是void
第三个参数:缓冲区字节个数
返回值:成功时,写入内容的字节个数会被返回,失败时返回-1。
![](https://file.jishuzhan.net/article/1713040254266511361/9e6d7e6e7ee4a003d12f67dd98dd80c6.webp)
c
#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{
umask(0);
//打开
int fd=open("log.txt",O_WRONLY|O_CREAT,0666);
if(fd<0)
{
perror("open");
return 1;
}
//写
const char* buffer="hello linux\n";
ssize_t num= write(fd,buffer,strlen(buffer)); //向文件中写入string,strlen(buffer)+1 需要加1吗?
//你以\0作为字符串的结尾,是C语言的规定,和我文件有什么关系呢?
if(num<0)
{
perror("write");
exit(2);
}
//关闭
close(fd);
return 0;
}
![](https://file.jishuzhan.net/article/1713040254266511361/bb129827345b346353ddda64587bb2c2.webp)
c
#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{
umask(0);
//打开
int fd=open("log.txt",O_WRONLY|O_CREAT,0666);
if(fd<0)
{
perror("open");
return 1;
}
//写
//const char* buffer="hello linux\n";
const char* buffer="aaaaaa\n";
ssize_t num= write(fd,buffer,strlen(buffer));
if(num<0)
{
perror("write");
exit(2);
}
//关闭
close(fd);
return 0;
}
![](https://file.jishuzhan.net/article/1713040254266511361/eda92548f8533b61d82d598e69995c00.webp)
为什么是这样的结果呢?
C语言以w方式打开文件,会先清空文件内容再写。
但是open("log.txt",O_WRONLY|O_CREAT,0666);只是直接覆盖,并不会清理。
这是因为我们少传一个参数O_TRUNC。
c
#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{
umask(0);
//打开
int fd=open("log.txt",O_WRONLY|O_CREAT|O_TRUNC,0666);
if(fd<0)
{
perror("open");
return 1;
}
//写
//const char* buffer="hello linux\n";
const char* buffer="aaaaaa\n";
ssize_t num= write(fd,buffer,strlen(buffer));
if(num<0)
{
perror("write");
exit(2);
}
//关闭
close(fd);
return 0;
}
![](https://file.jishuzhan.net/article/1713040254266511361/621058edcc5271397ade0baf0143cded.webp)
以前我们C接口,fopen,以w/a方法打开文件,就是库里直接帮我们把下面工作做好了。
3.4read
![](https://file.jishuzhan.net/article/1713040254266511361/1b19d032234140c9200c64e13fd8d7b9.webp)
第一个参数:从那个文件中读
第二个参数:读到那个缓冲区
第三个参数:读多少个字节
返回值:成功返回读取字节的个数,失败返回-1
![](https://file.jishuzhan.net/article/1713040254266511361/6ecbc4041b3a54198a99ce9683a1493a.webp)
c
#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{
umask(0);
//打开
//bin int fd=open("log.txt",O_WRONLY|O_CREAT|O_TRUNC,0666);
int fd=open("log.txt",O_RDONLY);
if(fd<0)
{
perror("open");
return 1;
}
//读
char buffer[1024];
ssize_t num=read(fd,buffer,sizeof(buffer)-1);
if(num > 0) buffer[num-1]=0; //0,\0,NULL--->0,,系统调用接口不管读的是什么类型文件,都会当作二进制处理,这里我们想读的是字符串,因此结尾加个\0
puts(buffer);
//关闭
close(fd);
return 0;
}
![](https://file.jishuzhan.net/article/1713040254266511361/e90f47a3e68d1bb14693901e6edfc3e1.webp)
3.5lseek
重新定位读写文件的偏移量
这个函数和fseek类似,这里不再演示。
3.6总结
![](https://file.jishuzhan.net/article/1713040254266511361/46a015990ecf75ec0b7db542f4f15a78.webp)
4.如何理解文件
文件操作的本质:进程和被打开文件的关系。
进程可以打开多个文件吗?--->可以--->系统中一定会存在大量的被打开的文件 --->被打开打开的文件,要不要被OS管理起来呢?--->要 ---> 如何管理?---> 先描述,在组织 ---> 操作系统为了管理对应打开的文件,必定要为文件创建对应的内核数据结构标识文件 --->struct _file{ } --->包含了文件大部分属性。
c
#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>
#define FILE_NAME(number) "log.txt"#number
int main()
{
umask(0);
//打开
//int fd=open("log.txt",O_WRONLY|O_CREAT|O_TRUNC,0666);
// int fd=open("log.txt",O_RDONLY);
int fd0=open(FILE_NAME(1),O_WRONLY|O_CREAT|O_TRUNC,0666);
int fd1=open(FILE_NAME(2),O_WRONLY|O_CREAT|O_TRUNC,0666);
int fd2=open(FILE_NAME(3),O_WRONLY|O_CREAT|O_TRUNC,0666);
int fd3=open(FILE_NAME(4),O_WRONLY|O_CREAT|O_TRUNC,0666);
int fd4=open(FILE_NAME(5),O_WRONLY|O_CREAT|O_TRUNC,0666);
printf("fd0:%d\n",fd0);
printf("fd1:%d\n",fd1);
printf("fd2:%d\n",fd2);
printf("fd3:%d\n",fd3);
printf("fd4:%d\n",fd4);
close(fd0);
close(fd1);
close(fd2);
close(fd3);
close(fd4);
return 0;
}
![](https://file.jishuzhan.net/article/1713040254266511361/7acb91a77378530d1efdc8ef550f88cf.webp)
文件创建成功,并且返回各自对应的文件描述符。
但是奇怪的是:
a.为什么从3开始呢?0,1,2去哪里了?
b.为什么是连续的小整数呢?--->什么会是连续的小整数呢?---> 猜测可能和数组有关
这里就不得不提到,C程序默认会打开三个标准输入,标准输出,标准错误。
FILE* fp=fopen();问FILE是什么呢?
int fd=open(); int 是文件描述符
我们知道C:fopen...是对底层系统调用接口的封装,而底层用的是文件描述符。
FILE是一个结构体 ----> 必须有一个字段存放文件描述
C调用文件函数的接口不仅对系统调用接口的封装,与此同时C语言FILE结构体也封装了操作系统内的文件描述符。
![](https://file.jishuzhan.net/article/1713040254266511361/24a99a5386748ba4fded18f12f2261d9.webp)
c
#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>
#define FILE_NAME(number) "log.txt"#number
int main()
{
umask(0);
printf("stdin->fd:%d\n",stdin->_fileno);
printf("stdout->fd:%d\n",stdout->_fileno);
printf("stderr->fd:%d\n",stderr->_fileno);
//打开
//int fd=open("log.txt",O_WRONLY|O_CREAT|O_TRUNC,0666);
// int fd=open("log.txt",O_RDONLY);
int fd0=open(FILE_NAME(1),O_WRONLY|O_CREAT|O_TRUNC,0666);
int fd1=open(FILE_NAME(2),O_WRONLY|O_CREAT|O_TRUNC,0666);
int fd2=open(FILE_NAME(3),O_WRONLY|O_CREAT|O_TRUNC,0666);
int fd3=open(FILE_NAME(4),O_WRONLY|O_CREAT|O_TRUNC,0666);
int fd4=open(FILE_NAME(5),O_WRONLY|O_CREAT|O_TRUNC,0666);
printf("fd0:%d\n",fd0);
printf("fd1:%d\n",fd1);
printf("fd2:%d\n",fd2);
printf("fd3:%d\n",fd3);
printf("fd4:%d\n",fd4);
close(fd0);
close(fd1);
close(fd2);
close(fd3);
close(fd4);
return 0;
}
文件描述符的本质:就是数组的下标。
进程与文件直之间对应的关系:进程通过文件描述符来指向文件的。
5.文件描述符(fd)分配规则
c
1 #include<stdio.h>
2 #include<string.h>
3 #include<sys/types.h>
4 #include<sys/stat.h>
5 #include<fcntl.h>
6 #include<unistd.h>
7 #include<stdlib.h>
8
9 int main()
10 {
11 umask(0);
12 int fd=open("log.txt",O_WRONLY|O_CREAT|O_TRUNC,0666);
13 if(fd == -1)
14 {
15 perror("open");
16 exit(1);
17 }
18 printf("fd:%d\n",fd);
19
20 close(fd);
21
22 return 0;
23 }
![](https://file.jishuzhan.net/article/1713040254266511361/edf9fcaf69a21665124a84f446c85a81.webp)
c
1 #include<stdio.h>
2 #include<string.h>
3 #include<sys/types.h>
4 #include<sys/stat.h>
5 #include<fcntl.h>
6 #include<unistd.h>
7 #include<stdlib.h>
8
9 int main()
10 {
11 close(0);
12 umask(0);
13 int fd=open("log.txt",O_WRONLY|O_CREAT|O_TRUNC,0666);
14 if(fd == -1)
15 {
16 perror("open");
17 exit(1);
18 }
19 printf("fd:%d\n",fd);
20
21 close(fd);
22
23 return 0;
24 }
![](https://file.jishuzhan.net/article/1713040254266511361/84d4dba1ad44f3602434d8f89f3983d8.webp)
c
1 #include<stdio.h>
2 #include<string.h>
3 #include<sys/types.h>
4 #include<sys/stat.h>
5 #include<fcntl.h>
6 #include<unistd.h>
7 #include<stdlib.h>
8
9 int main()
10 {
11 close(2);
12 umask(0);
13 int fd=open("log.txt",O_WRONLY|O_CREAT|O_TRUNC,0666);
14 if(fd == -1)
15 {
16 perror("open");
17 exit(1);
18 }
19 printf("fd:%d\n",fd);
20
21 close(fd);
22
23 return 0;
24 }
![](https://file.jishuzhan.net/article/1713040254266511361/1f596a0c7cdab5f77911524599cf5ec6.webp)
对比三次运行结果,发现每次创建新文件fd都不同,在仔细发现这是由于close(fd)关闭文件,所导致的结果。
由图来解释上述原因
![](https://file.jishuzhan.net/article/1713040254266511361/8bd5c00dda5f67c48bc173343db47d5f.webp)
当我们关闭fd为0的文件,重新打开一个文件的时候,进程扫描文件描述符表:从小到大,按照循序寻找最小的且没有被占用的fd。(fd的分配规则)
c
1 #include<stdio.h>
2 #include<string.h>
3 #include<sys/types.h>
4 #include<sys/stat.h>
5 #include<fcntl.h>
6 #include<unistd.h>
7 #include<stdlib.h>
8
9 int main()
10 {
11 // close(0);
12 // close(2);
13 close(1);
14 umask(0);
15 int fd=open("log.txt",O_WRONLY|O_CREAT|O_TRUNC,0666);
16 if(fd == -1)
17 {
18 perror("open");
19 exit(1);
20 }
21 printf("fd:%d\n",fd);
22
23 close(fd);
24
25 return 0;
26 }
![](https://file.jishuzhan.net/article/1713040254266511361/1a5b8f8f3698ae31ed0ccdd3c17d59b7.webp)
close(1),为什么没有打印新建文件fd呢?
printf("%d\n",fd); printf会把内容打印到stdout文件中。
但是close(1)关闭标准输出stdout--->显示器,int fd=open();新打开的文件fd是1。
stdout-->fd-->1,虽然我们手动关闭了stdout,但是系统并不知道,还以为fd为1的位置是stdout,但是这个位置现在已经被新打开的文件占用了,所以打印到了新打开的文件里。
c
1 #include<stdio.h>
2 #include<string.h>
3 #include<sys/types.h>
4 #include<sys/stat.h>
5 #include<fcntl.h>
6 #include<unistd.h>
7 #include<stdlib.h>
8
9 int main()
10 {
11 // close(0);
12 // close(2);
13 close(1);
14 umask(0);
15 int fd=open("log.txt",O_WRONLY|O_CREAT|O_TRUNC,0666);
16 if(fd == -1)
17 {
18 perror("open");
19 exit(1);
20 }
21 printf("fd:%d\n",fd);
22
23 //这里必须刷新一下,不然log.txt里面没有内容,这里和缓冲区有关,下面讲
24 fflush(stdout);
25 close(fd);
26
27 return 0;
28 }
![](https://file.jishuzhan.net/article/1713040254266511361/12b64ba16331284d5ce0d264a477aca2.webp)
本来应该打印到显示器文件中,但是确写到文件里了。------>重定向
有关重定向问题,下篇博文解释!