PIPE(2)                                                                               Linux Programmer's Manual                                                                              PIPE(2)
NAME
       pipe, pipe2 - create pipe
SYNOPSIS
       #include <unistd.h>
       int pipe(int pipefd[2]);
       #define _GNU_SOURCE             /* See feature_test_macros(7) */
       #include <fcntl.h>              /* Obtain O_* constant definitions */
       #include <unistd.h>
       int pipe2(int pipefd[2], int flags);
DESCRIPTION
       pipe()  creates  a pipe, a unidirectional data channel that can be used for interprocess communication.  The array pipefd is used to return two file descriptors referring to the ends of the
       pipe.  pipefd[0] refers to the read end of the pipe.  pipefd[1] refers to the write end of the pipe.  Data written to the write end of the pipe is buffered by the kernel until  it  is  read
       from the read end of the pipe.  For further details, see pipe(7).
       If flags is 0, then pipe2() is the same as pipe().  The following values can be bitwise ORed in flags to obtain different behavior:
       O_NONBLOCK  Set the O_NONBLOCK file status flag on the two new open file descriptions.  Using this flag saves extra calls to fcntl(2) to achieve the same result.
       O_CLOEXEC   Set the close-on-exec (FD_CLOEXEC) flag on the two new file descriptors.  See the description of the same flag in open(2) for reasons why this may be useful.
RETURN VALUE
       On success, zero is returned.  On error, -1 is returned, and errno is set appropriately.
ERRORS
       EFAULT pipefd is not valid.
       EINVAL (pipe2()) Invalid value in flags.
       EMFILE Too many file descriptors are in use by the process.
       ENFILE The system limit on the total number of open files has been reached.

#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
#include<stdlib.h>
int main()
{
  int fd[2];
  if(pipe(fd)!=0)
  {
    perror("pipe");
    exit(-1);
  }
  printf("pipe[0]=%d\n",fd[0]);
  printf("pipe[1]=%d\n",fd[1]);
  return 0;
}

#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
#include<stdlib.h>
#include <string.h>
int main()
int main()
{
  int fd[2];
  if(pipe(fd)!=0)//创建管道
  {
    perror("pipe");
    exit(-1);
  }
  //打印文件描述符
  printf("pipe[0]=%d\n",fd[0]);
  printf("pipe[1]=%d\n",fd[1]);
  //实现进程键通信
  pid_t id =fork();
  if(id<0)
  {
    perror("fork");
    exit(1);
  }
  //我们向让父进程执行读取，子进程执行写入
  //0----->就是读取端，1----->就是写入端
  else if(id==0)//创建子进程
  {
    //child
    //关闭读写端，建立一个单向的管道
    //子进程把文件描述符也都给继承下来了
    close(fd[0]);
    const char* msg="hello world";
    int cout=0;
    //我们还可以使用read 和write进行读写操作
    while(1)
    {
    //write(fd[1],msg,strlen(msg));//我们不需要+1,因为\0本身只是c语言的标准，
    write(fd[1],"a",1);//子进程不断往管道里面写入，但是父进程不读
    cout++;
    printf("cout=%d\n",cout);
    //write的动作就是pipe里面只要有缓冲区区域就一直写入
    //当我们一直些的时候，写满64KB的时候，写段就不再写入了，因为管道有大小，
    //当写端写满的时候，为什么不写了，
    //因为要让读端来读，
    }
    exit(0);
    //dup2(fd[1],1);
  }
  else 
  {
    //father
    close(fd[1]);
    //父进程就一直在那里读取
    //while(1)
    //{
    //  char buf[32]={0};
    //  ssize_t ret=read(fd[0],buf,sizeof(buf));//如果此时ret=0说明子进程关闭文件描述符了，相当于读到文件的结尾了
    //  //read是只要有数据就可以一直读取
    //  //这就叫字节流
    //  if(ret==0)
    //    break;
    //  else 
    //  {
    //  buf[ret]=0;//把\0位置就设置为0
    //  printf("child say : %s\n",buf);
    //  //我们没有让父进程去sleep
    //  }
    dup2(fd[0],0);//绑定打印到文件里面
    //}
    sleep(1);
    //dup2(fd[0],0);
  }
  return 0;
}