Operating system 父级和6个子级之间的命名管道

我想写一个程序，其中父母有6个孩子，每个孩子都有一个id。（0-maxchild-1） 首先，父级将最后一个子id-1（maxchild-1）放入管道，然后，每个子级都应检查管道中的数字是否等于其id，以及是否等于且不为零：子级应将管道中的数字-1（pipevalue-1）放入管道中，直到管道中的数字为零。如果子级从管道中读取的管道值为零，则子级应再次输入零并使其自身完成

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <sys/stat.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>

#define MAXCHILD 6
#define MAXIMUM 100

struct child_proc
{
    pid_t pid;
    int id;
};


int main()
{
    int inChild=0;
    int pipe, flag=0;
    char path[30];
    char buffer[256];
    bzero(buffer,256);

    struct child_proc child_array[MAXCHILD];

    sprintf(path,"1.pipe");

    mkfifo(path,0777);

    for (int i=0;i<MAXCHILD;i++)
    {

        int r =fork();
         if(r==0){
            child_array[i].pid = getpid();
            child_array[i].id = i;
            inChild=1;
             break;
        }
        /*if(r>0)
        {
            if(flag == 0) // run only once
            {
                pipe=open(path,O_WRONLY);
                sprintf(buffer,"%d",MAXCHILD - 1);
                write(pipe,buffer,strlen(buffer));
                flag ++;
                //sleep(15);
            }
        }*/
    }


    while (inChild==1)
    { // in child
        for(int j=0; j<MAXCHILD; j++)
        {
            if(getpid() == child_array[j].pid)
            {
                printf("Child id %d starts\n", child_array[j].id);
                pipe=open(path,O_RDONLY|O_NONBLOCK);
                read(pipe,buffer,255);
                printf("child id %d pipevalue %d\n",child_array[j].id, atoi(buffer));
                
                pipe=open(path,O_WRONLY);
                if(atoi(buffer) == child_array[j].id)
                {
                    //bzero(buffer,256);                
                    sprintf(buffer,"%d", child_array[j].id - 1);
                    printf("child -> %s\n",buffer);
                    write(pipe,buffer,strlen(buffer));
                    sleep(1);
                }
                else if(atoi(buffer)==0)
                {

                    //bzero(buffer,256);
                    sprintf(buffer,"%d", 0);
                    write(pipe,buffer,strlen(buffer));
                    printf("Child id %d reach the point\n", child_array[j].id);
                    exit(0);

                }
            }
        }
    }

    pipe=open(path,O_WRONLY);
    while(inChild==0)
    { // in parent
        printf("parent id is: %d\n",getpid());
        if(flag == 0) // run only once
        {
            sprintf(buffer,"%d",MAXCHILD - 1);
            printf("parent -> %s\n", buffer);
            write(pipe,buffer,strlen(buffer));
            flag ++;
            sleep(15);
        }

    }


return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义MAXCHILD 6
#定义最大值100
结构子进程
{
pid_t pid；
int-id；
};
int main（）
{
int-inChild=0；
int管道，标志=0；
字符路径[30]；
字符缓冲区[256]；
b0（缓冲器，256）；
结构child_proc child_数组[MAXCHILD]；
sprintf（路径“1.管道”）；
mkfifo（路径0777）；
对于（int i=0；i0）
{
if（flag==0）//只运行一次
{
管道=开放（仅限路径O_）；
sprintf（缓冲区，“%d”，MAXCHILD-1）；
写入（管道、缓冲区、strlen（缓冲区））；
flag++；
//睡眠（15）；
}
}*/
}
而（英寸=1）
儿童{//
对于（int j=0；j