管道是两个进程的连接器，单向，一端作为输入。普通管道只能用于父子进程的进程间通信，命名管道可以实现不同进程间的通信。
 
创建管道函数
 
 
 
 
 
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<wait.h>
#include<errno.h>
#include<signal.h>
#include <setjmp.h>

#include<sys/types.h>
#include<fcntl.h>
#include<sys/stat.h>
/*int pipe(int pipefd[2]);
  参数保存系统返回的描述符号，0读，1写
  返回0表示成功
  返回-1表示函数执行失败
  */
/*首先创建了一个管道，然后创建了子进程，利用该管道从父进程向子进程发送信息。消息是程序的命令行参数，子进程收到父进程传送的消息后输出。*/
/*本例里面每个文件描述符都被关闭了两次，是因为在多进程的环境下，一个有效的管道描述符在并发子进程时会将被所有进程共享的文件表里面的引用次数+1，这里的每一次
都是将其引用计数-1在一个描述符的引用次数为0情况下才会真正的关闭一个描述符*/
int main(int argc, char *argv[])
{
    int pfd[2];	//保存管道的文件描述符
    pid_t cpid;//保存进程标示符
    char buf;//定义变量
    if(argc != 2)
    {
        fprintf(stderr,"Usage: %s <string>\n",argv[0]);//提示用法信息
        exit(0);
    }
    if (pipe(pfd) == -1)
    {
        perror("pipe");
        exit(EXIT_FAILURE);
    }
    cpid = fork();//创建进程
    if (cpid == -1)
    {
        perror("fork");
        exit(EXIT_FAILURE);
    }
    
    if (cpid == 0)//子进程
    {
        close(pfd[1]);//关闭写管道描述符
        while (read(pfd[0], &buf, 1) > 0)//管道循环读数据
            write(STDOUT_FILENO, &buf, 1);//输出读到数据
        
        write(STDOUT_FILENO, "\n", 1);//输出从管道里读取的数据
        close(pfd[0]);//退出子进程
        exit(EXIT_SUCCESS);
    }
    else
    {
        close(pfd[0]);//关闭文件描述符
        write(pfd[1], argv[1], strlen(argv[1]));//向管道写入命令行参数1
        close(pfd[1]);//关闭写管道描述符
        wait(NULL);//等待子进程退出
        exit(EXIT_SUCCESS);
    }
    return 0;
}
 
 
 
 
 
 
 
 
 
 

maya2018曲线创建管道
 
b站视频链接https://www.bilibili.com/video/BV1di4y1s7FJ

我们有一个这样的场景：主程序希望与子程序进行通信。我们用pipe()函数为他们创建管道，这样他们就可以通过管道来通信了。
 为了演示方便我们只考虑：
 子程序把数据发送到父进程中来的情况。因此要用管道把子进程的标准输出和父进程的标准输入连接起来
 
我们将用pipe()函数建立管道。每当我们打开数据流时，它都会加入描述符表。pipe()函数也是如此，它创建两条相连的数据流，并把它们加到描述符表中，然后只要我们往其中一条数据流中写数据，就可以从另一条数据流中读取。pipe()在描述符表中创建这两项时，会把它们的文件描述符存放在一个包含两个元素的数组中。
 
int fd[2];  //文件描述符将保存在fd数组中。
if(pipe(fd) == -1){
        fprintf(stderr,"Can't create the pipe!");
        exit(2);
} 
 
pipe()函数创建了管道，并返回了两个描述符：fd[0]用来从管道读数据，fd[1]用来向管道写数据。我们将在父、子进程中使用这两个描述符。
 
我们通过一个实例来说明：
 aaa.c
 
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

void open_url(char *url);
int main(){
        int fd[2];
        if(pipe(fd) == -1){ //创建管道，并把文件描述符保存在fd[0]和fd[1]中。
                fprintf(stderr,"%s\n","Can't create the pipe!");
                exit(1);
        }
        pid_t pid = fork();
        if(pid == -1){
                fprintf(stderr,"%s\n","Can't fork process!");
                exit(2);
        }
        if(!pid){ //能进这里，表示已在子进程中
                dup2(fd[1],1); //把标准输出设为管道写入端
                close(fd[0]); //因为子进程不会去读取管道，因此将读取端关闭
                if(execl("bbb","bbb",NULL) == -1){
                        fprintf(stderr,"%s\n","Can't open subprocess");
                        exit(1);
                }
        }
        //从这开始是属于父进程的
        dup2(fd[0],0);  //把标准输入设为管道读取端
        close(fd[1]);//因为父进程不会向子进程发数据，无需写入管道，因此将写入端关闭
        char line[255];
        while(fgets(line,255,stdin)){
                        open_url(line+1);
        }
        return 0;
}
void open_url(char *url){
        char launch[255];
        //sprintf(launch,"cmd /c start %s",url);  //在windows上打开网页
       // system(launch);
        sprintf(launch,"x-www-browser '%s' &",url);//在Linux上打开网页
        system(launch);
        //sprintf(launch,"open '%s'",url); //在Mac上打开网页
        //system(launch);
}
 
bbb.c
 
#include <stdio.h>
int main(){
        char line[255];
        fgets(line,255,stdin);
        printf("%s",line);
        return 0;
}
 
编译运行：
 
~/Desktop/MyC$ gcc aaa.c -o aaa
~/Desktop/MyC$ gcc bbb.c -o bbb
~/Desktop/MyC$ ./aaa
|
 
查进程信息：
 
~$ ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
wong     17525  5363  0 17:47 pts/1    00:00:00 ./aaa
wong     17526 17525  0 17:47 pts/1    00:00:00 bbb
 
输入地址按回车：
 
~/Desktop/MyC$ ./aaa
http://www.baidu.com
 
接着就会打开浏览器。
 
管道是文件吗？这不一定。这取决于操作系统创建管道的方式，一般来说用pipe()创建的管道都不是文件。而创建基于文件的管道，通常叫做有名管道或FIFO文件（先进先出文件）。
 
因为基于文件的管道有名字，所以两个进程只要知道管道的名字也能用它来通信，即使它们是非父子进程关系。要使用有名管道，可以通过使用mkfifo()系统调用来实现。如果不是通过文件来实现管道的话，那通常是用内存，数据写到内存某个位置，然后再从另一个位置读取。
 
如果试图读取一个空的管道，也不会发生错误，因为程序会等待管道中出现东西。
 
父进程是如何知道子进程结束的？
 其实，当子进程结束时，管道会关闭。fgets()将会收到EOF(End Of File,文件结束符） ，于是fgets()函数返回0，循环就结束了。
 
另外，管道只能单向通信。但是可以通过创建两个管道，一个从父进程连接到子进程，另一个从子进程连接到父进程来实现双向通信 。
 
谢谢阅读！

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>

int runcmd( char* lpCmd )
{
    char buf[2048] = {0};    //缓冲区
    DWORD len;
    HANDLE hRead, hWrite;    // 管道读写句柄
    STARTUPINFO si;
    PROCESS_INFORMATION pi;
    SECURITY_ATTRIBUTES sa;
    
    //ZeroMemory( buf, 2047 );
    sa.nLength = sizeof( sa );
    sa.bInheritHandle = TRUE;    // 管道句柄是可被继承的
    sa.lpSecurityDescriptor = NULL;
    
    // 创建匿名管道，管道句柄是可被继承的
    if( !CreatePipe( &hRead, &hWrite, &sa, 2048 ) )
    {
        printf( "管道创建失败!(%#X)\n", (unsigned int)GetLastError() );
        return 1;
    }

    ZeroMemory( &si, sizeof( si ) );
    si.cb = sizeof( si );
    si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
    si.wShowWindow = SW_HIDE;
    si.hStdError = hWrite;
    si.hStdOutput = hWrite;

    // 创建子进程,运行命令,子进程是可继承的
    if ( !CreateProcess( NULL, lpCmd, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi ) )
    {
        printf( "创建进程失败!(%#x)\n", (unsigned int)GetLastError() );
        CloseHandle( hRead );
        CloseHandle( hWrite );
        return 1;
    }
    // 写端句柄已被继承,本地需要关闭,不然读管道时将被阻塞
    CloseHandle( hWrite );
    // 读管道内容,并显示
    while ( ReadFile( hRead, buf, 2047, &len, NULL ) )
    {
        printf( buf );
        ZeroMemory( buf, 2047 );
    }
    CloseHandle( hRead );
    return 0;
}

int main( int argc, char** argv )
{
      char cmd[256];
      printf( "输入命令行:" );
      gets( cmd );
      runcmd( cmd );
      system( "pause" );
      return 0;
}