Linux下一切皆文件，所谓的终端那个黑框也可以视为一个文件，在Linux驱动开发中各个设备也可以被认为是文件操作，所以文件的操作很重要。我们通常将键盘叫做标准输入设备、将显示器叫做标准输出设备，下面由几个例子来解释文件的标准输入、标准输出、输出重定向。

一、命令行下的标准输入、标准输出、输出重定向

        在命令行中可以使用echo命令将想输的字符串输出在终端上，结果如下：

lzn@ubuntu:~$ echo abcdefdg
abcdefdg

        这就是标准输出。

        在终端中可以使用cat命令来展示标准输入，cat命令后加文件，会在终端展示文件内容，如果不加文件，则你从键盘输入什么消息，他就会在终端展示什么消息，结果如下：

lzn@ubuntu:~$ cat abc
这里是文件的内容
lzn@ubuntu:~$ cat
现在是键盘输入的内容
现在是键盘输入的内容
只有使用Ctrl+C才可以退出回到命令行
只有使用Ctrl+C才可以退出回到命令行
^C
lzn@ubuntu:~$

        这里展示的是标准输入，其实也包含了标准输出，因为也是在终端显示的信息。cat abc是查看abc文件的内容。

        重定向多用于输出重定向，所以下面只在终端做输出重定向的例子，输出重定向用>,>>,2>。输入重定向号用符号<表示，<表示输出重定向并覆盖以前的数据，<<表示输出重定向追加在以前的数据后。2>表示错误输出，最后还是会把数据输出在终端上即输出在标准输出设备上。下面是例子（test是我的测试文件）：

lzn@ubuntu:~$ echo abcd
abcd
lzn@ubuntu:~$ echo abcd > test
lzn@ubuntu:~$ cat test
abcd
lzn@ubuntu:~$ echo efgh > test
lzn@ubuntu:~$ cat test
efgh
lzn@ubuntu:~$ echo abcd >> test
lzn@ubuntu:~$ cat test
efgh
abcd
lzn@ubuntu:~$ echo aaaaaaaa 2> test
aaaaaaaa
lzn@ubuntu:~$ cat test
注意：错误输出虽然不会输出在test文件里，但是还是会清空test文件，还有2>>重定向就不演示了。

        以上内容就是命令行中标准输入、输出、重定向的用法。

二、文件操作中的标准输入、输出、重定向用法

        每一个文件都有自己的文件描述符，系统会将0、1、2分配给标准输入、标准输出、错误输出。所以我们打开的文件名是从3开始的。当然我们也可以将文件描述符改为0、1、2，这里就不说了。 

        下面根据代码来展示标准输入输出、重定向的用法。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#define BUFFMAX 32

int main(int argc,char **argv)    //argc表示执行文件后的参数数量，argv[]表示后面参数代表的                                    
                                    文件，argv[0]代表本段代码的文件名
{
        if(argc<2)
        {
                perror("少于1个文件！\n");
                exit(1);
        }
        int fd0;
        if((fd0=open(argv[1],O_RDONLY))<0)    //打开文件并判断文件是否正确打开
        {
                perror("open error\n");
                exit(1);
        }
        int len;
        char buf[BUFFMAX];
        while(1)
        {
                len=read(fd0,buf,BUFFMAX);    //read和write都是简单的函数，不懂可以去搜
                if(len>0)
                {
                        write(1,buf,len);     //这里1表示标准输出，就是将数据显示在终端上
                }
                if(len==0)
                        break;
        }
        close(fd0);
        exit(0);
}

        以上代码功能就是将文件的内容标准输出，当然输出的文件就是屏幕即终端界面，运行结果如下：

lzn@ubuntu:~$ ./a a.c    //执行a.c的代码来输出a.c的程序，以下是输出，只截取部分。
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#define BUFFMAX 32

        那如何将输出重定向到其他文件呢，只需要再打开一个文件，将其定向为输出位置，代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#define BUFFMAX 32

int main(int argc,char **argv)
{
        if(argc<2)
        {
                perror("少于2个文件！\n");
                exit(1);
        }
        int fd0,fd1;
        if((fd0=open(argv[1],O_RDONLY))<0)
        {
                perror("open error\n");
                exit(1);
        }
        if((fd1=open(argv[2],O_WRONLY))<0)
        {
            perror("open error\n");
                  close(fd0);
            exit(1);
        }

        int len;
        char buf[BUFFMAX];
        while(1)
        {
                len=read(fd0,buf,BUFFMAX);
                if(len>0)
                {
                        write(fd1,buf,len);  //把刚才的1换成了另一个文件的文件描述符
                }
                if(len==0)
                        break;
        }
        close(fd0);
        close(fd1);
        exit(0);
}

        下面是执行结果：

lzn@ubuntu:~$ vim a.c
lzn@ubuntu:~$ gcc -o a a.c
lzn@ubuntu:~$ ./a a.c test   //执行a.c的代码将a.c程序重定向输出到test文件中。以下只是部分输                            
                               出
lzn@ubuntu:~$ cat test
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#define BUFFMAX 32
int loop=0;

        以上就是文件操作中的标准输入、输出、重定向用法。感兴趣的可以去看看Unix环境高级编程，Linux开发的圣经值得反复读。

                  Linux的标准输入、标准输出和标准错误

什么是文件描述符？
文件描述符是一个简单的正整数，用以标明每一个被进程所打开的文件和socket。
最前面的三个文件描述符（0，1，2）分别与标准输入（stdin），标准输出（stdout）和标准错误（stderr）对应。

Unix/Linux/BSD 都有三个特别文件，分别
1）标准输入 即 STDIN , 在 /dev/stdin ,
一般指键盘输入, shell里代号是 0

2) 标准输出 STDOUT, 在 /dev/stdout,
一般指终端(terminal), 就是显示器, shell里代号是 1

3) 标准错误 STDERR, 在 /dev/stderr
也是指终端(terminal), 不同的是, 错误信息送到这里
shell里代号是 2 

2, 3用些例子再表达一下

User@User-PC ~
$ ls /dev/stdin
/dev/stdin@

User@User-PC ~
$ ls -l /dev/std*
lrwxrwxrwx 1 User Users 15 Mar  1  2008 /dev/stderr -> /proc/self/fd/2
lrwxrwxrwx 1 User Users 15 Mar  1  2008 /dev/stdin -> /proc/self/fd/0
lrwxrwxrwx 1 User Users 15 Mar  1  2008 /dev/stdout -> /proc/self/fd/1

将标准输出导向到文件, ls 1> log1.txt，缩写就是 ls > log1.txt

User@User-PC ~
$ ls 1> log1.txt

User@User-PC ~
$ cat log1.txt 
Mail/
News/
a.txt
aa*
awkscr
b.txt
bb*
bin/
cc
cgitest.rex*
dd*
irc-sh*
junk
lib/
log1.txt
lynx.cfg
matrix/
perlscr*
pp*
rexx_script/
rrr
testawk
tmp/
trash

标准错误的演示

User@User-PC ~
$ ls llll 1> log2.txt
ls: 无法存取 llll: No such file or directory

再次执行，但这次没有这个文件llll, 出现错误讯息

User@User-PC ~
$ cat log2.txt 

User@User-PC ~
$ file log2.txt
log2.txt: empty

输出没有导向到文件，文件是空文件

User@User-PC ~
$ ls llll 2> log2.txt

User@User-PC ~
$ cat log2.txt 
ls: 无法存取 llll: No such file or directory

User@User-PC ~
$ 

再次执行刚才的命令，只是将 1> log2.txt 改为 2> log2.txt
这次就成功把错误讯息导向至文件了

命令 2>&1 > file, 如

User@User-PC ~
$ echo 123 | if grep -E '[0-9]+' 2>&1 > /dev/null ; then echo "This is number."; fi
This is number.

grep 标准输出和标准错误 都导向到系统‘黑洞’，不会再屏幕上显示什麼

最后再解释一下：

> 默认为标准输出重定向，与 1> 相同
2>&1 意思是把 标准错误输出 重定向到 标准输出.
&>file 意思是把 标准输出 和 标准错误输出 都重定向到文件file中

1.&>file或n>&m均是一个独立的重定向符号，不要分开来理解。
2.明确文件和文件描述符的区别。
3.&>file表示重定向标准输出和错误到文件
例如：
rm -f $(find / -name core) &> /dev/null，/dev/null是一个文件，这个文件比较特殊，所有传给它的东西它都丢弃掉。
4.n>&m表示使文件描述符n成为输出文件描述符m的副本。这样做的好处是，有的时候你查找文件的时候很容易产生无用的信息,如:2> /dev/null的作用就是不显示标准错误输出；另外当你运行某些命令的时候,出错信息也许很重要,便于你检查是哪出了毛病,如:2>&1
例如：
注意，为了方便理解，必须设置一个环境使得执行grep da *命令会有正常输出和错误输出，然后分别使用下面的命令生成三个文件：

grep da * > greplog1
grep da * > greplog2 1>&2   
grep da * > greplog3 2>&1  //grep da * 2> greplog4 1>&2 结果一样
#查看greplog1会发现里面只有正常输出内容
#查看greplog2会发现里面什么都没有
​​​​​​​#查看greplog3会发现里面既有正常输出内容又有错误输出内容

在/usr/include/unistd.h中有如下定义：

/* Standard file descriptors.  */
#define STDIN_FILENO   0 /* Standard input.  */
#define STDOUT_FILENO  1 /* Standard output.  */
#define STDERR_FILENO  2 /* Standard error output.  */

#include <stdio.h>
#include <string.h>

/*客户端的处理过程*/
void process_conn_client(int s) {
    ssize_t size = 0;
    char buffer[1024]; /*数据的缓冲区*/

    for (;;) { /*循环处理过程*/
        /*从标准输入中读取数据放到缓冲区buffer中*/
        size = read(0, buffer, 1024);
        if (size > 0) {
            /*读到数据*/
            write(s, buffer, size); /*发送给服务器*/

            size = read(s, buffer, 1024); /*从服务器读取数据*/
            write(1, buffer, size); /*写到标准输出*/
        }
    }
}

/*服务器对客户端的处理*/
void process_conn_server(int s) {
    ssize_t size = 0;
    char buffer[1024]; /*数据的缓冲区*/
    for (;;) { /*循环处理过程*/
        size = read(s, buffer, 1024); /*从套接字中读取数据放到缓冲区buffer中*/

        if (size == 0) { /*没有数据*/
            return;
        } 

        /*构建响应字符，为接收到客户端字节的数量*/
        sprintf(buffer, "%d bytes altogether/n", size);
        write(s, buffer, strlen(buffer) + 1);/*发给客户端*/
    }
}
}

# app > out.log // 这样在代码中write(1, buf, size)就直接写入到文件之中了，无需在代码中操作文件