通过管道和重定向实现linux管道命令（二）

    在我的“通过管道和重定向实现linux管道命令”当中实现cat file | sort命令，没有使用标准I/O函数库中提供的popen()函数和pclose()函数，在本文中，我们一起探讨一下通过这两个标准的I/O函数来实现上述这个命令。

    先看一下这两个函数的定义吧：

FILE * popen(const char *command, const char *type);

    popen()函数用来创建一个管道并启动另外一个进程，新启动的进程要么从该管道当中读出标准输入（输入重定向），要么向该管道写入标准输出（输出重定向）。

    具体的第二个参数type表示I/O模式的类型。如果command命令的输出作为其他命令的输入（输出重定向），type为“r”权限；如果command命令的输入为其他命令的输出（输入重定向），type为“w”权限。

int pclose(FILE *stream);

    这个函数用来关闭由popen()创建的标准I/O流，等待其中的命令终止，然后返回给shll的终止状态。

    在我们对"cat file | sort"程序进行修改之前，先看一个简单的程序：

1. #include <stdio.h>
   
2. #include <unistd.h>
   
3. #include <stdlib.h>
   
4. 
   
5. #define MAXLINE 80
   
6. 
   
7. int main()
   
8. {
   
9.     FILE *fp;
   
10.     char buf[MAXLINE], command[MAXLINE];
    
11.     int n;
    
12.     
    
13.     n = fgets(buf, MAXLINE, stdin);
    
14.     n = strlen(buf);
    
15.     if(buf[n-1] == '\n') {
    
16.         n--;
    
17.     }
    
18. /*有关snprintf()函数的是有，具体可查阅printf()函数族的使用*/
19.     snprintf(command, sizeof(command), "head %s", buf);
    
20.     fp = popen(command, "r");
    
21.     while(fgets(buf, MAXLINE, fp) != NULL) {
    
22.         fputs(buf, stdout);
    
23.     }
    
24.     pclose(fp);
    
25.     return 0;
    
26. }

执行结果如下：

1. ^_^[sunny@sunny-laptop ~/summer]47$ ./a.out
   
2. file            //file是我的输入，下面都是file文件当中的内容
   
3. dsf
   
4. abcde
   
5. 92381
   
6. 8232
   
7. sadf
   
8. 872
   
9. 1988
   
10. 2000
    
11. 1022
    
12. 2012
    
13. ^_^[sunny@sunny-laptop ~/summer]48$

    程序说明：在调用popen()函数，就是创建了一个新的进程，同时创建了一个管道，注意，type的类型为“r”说明这里是输出重定向，也就是将command的输出作为其他命令的输入，写到创建的管道当中，并不是将其执行的结果输出到标准输出上。下来的话，通过对fp流的读取操作，读取管道当中command的输出结果，为了查

看结果是不是正确的，我们将其显示在了标准输出。

    下面实现"cat file | sort"命令：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. #include <sys/types.h>
   
5. #include <sys/stat.h>
   
6. #include <fcntl.h>
   
7. 
   
8. #define MAXLEN 80
   
9. #define MAX 1024
   
10. 
    
11. int main()
    
12. {
    
13.     FILE *fpin, *fpout;
    
14.     char command1[MAXLEN]={0}, command2[MAXLEN]={0}, buff[MAX]={0};
    
15. 
    
16.     snprintf(command1, sizeof("cat file"), "cat file");
    
17.     snprintf(command2, sizeof("sort"), "sort");
    
18.     fpin = popen(command1, "r"); //输出重定向
    
19.     fpout = popen(command2, "w"); //输入重定向
    
20. 
    
21.     while(read(fileno(fpin), buff, MAX) != 0) {
    
22.         write(fileno(fpout), buff, MAX);
    
23.     }
    
24. /*
    
25.  *或者这个while循环可以用这个while循环来代替
    
26.  *
    
27.     while(fgets(buff, MAX, fpin) != NULL) {
    
28.         fputs(buff, fpout);
    
29.     }
    
30. */
    
31.     pclose(fpin);
    
32.     pclose(fpout);
    
33.     return 0;
    
34. }

    这个程序的执行结果是：

1. ^_^[sunny@sunny-laptop ~/summer]84$ ./a.out
   
2. 
   
3. 1022
   
4. 1988
   
5. 2000
   
6. 2012
   
7. 8232
   
8. 872
   
9. 92381
   
10. abcde
    
11. dsf
    
12. fan
    
13. sadf
    
14. ^_^[sunny@sunny-laptop ~/summer]85$

    程序说明：首先使用snprintf()函数将两个通过管道要执行的命令分别存放在command1和command2当中，然后调用popen函数两次，第一个是所谓的输出重定向，将cat file的结果输入到popen()创建的管道当中，第二个是所谓的输入重定向，将管道当中的数据作为sort命令的输入。之后，通过一个while（）循环，读取第一个管道当中的数据到buff变量当中，然后把buff变量当中的数据输入到第二个管道当中，作为sort命令的输入。

    小结：在这次实现这个命令的时候，是创建了两个管道，之前的话，只有创建了一个管道就可以实现，但是如果要通过这两个标准的I/O函数来实现的话，我目前没有想到只创建一个管道就来实现的方法。