C 叉子+；管道问题

我有一个简单的程序，我用叉子和管道学习目的的问题。 我想要一个孩子将一些数据发送给父母，而这个（父母）将数据再次发送给孩子

结果是，父对象的行为类似于管道是非阻塞的，而子对象的行为类似于管道是阻塞的。但是我没有使用任何代码来说明管道是非阻塞的

让我展示一下：

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

void WriteStr(char* inStr)
{
    write(1,inStr,strlen(inStr));
}

int main(void){

    char *cad1 = "Introdueix un valor:  ";
int bytesr = 0;
char valor[256];

//Un pipe serveix solament per una comunicació unidereccional, 
//si es necessari que pare i fill es comuniquin en amdos sentits, 
//s'hauran d'utilitzar dos pipes.

int pip_fill[2];    //pip_fp[0]: file descriptor de lectura
                //pip_fp[1]: file descriptor d'escriptura

int pip_pare[2];    //pip_pf[0]: file descriptor de lectura
                //pip_pf[1]: file descriptor d'escriptura
int pid, nbytes = 0;
char cad[256];
int num = 0;

if (pipe (pip_fill)<0){
    write (1,"Pipe error!!!!\n",15);
    exit (1);
}

if (pipe (pip_pare)<0){
    write (1,"Pipe error!!!!\n",15);
    exit (1);
}

fflushnou();

pid = fork();
switch (pid){
    case -1:    
            //Error
            write (2,"Tractar_Valor: Error!!!!\n",25);
            exit (-1);
    case 0:
            //Fill
            //printf("Fill: fp[0]:%d fp[1]:%d pf[0]:%d pf[1]:%d \n",pip_fp[0],pip_fp[1],pip_pf[0],pip_pf[1]);
            close(pip_fill[0]);
                close(pip_pare[1]);

            while(1){
                bytesr = read(0, valor, 256);

                valor[bytesr] = '\0';

                write(pip_fill[1],valor,strlen(valor)); //el fill escriu a la pipe la var valor

                WriteStr("Fill avans\n");
                nbytes = read(pip_pare[0],cad,strlen(cad)); //el fill llegeix de la pipe la var un cop ha estat tractada per el pare
                WriteStr("Fill despres\n");

                if (nbytes != 0){   //vol dir que hem llegit algo per la pipe pip_pf
                    write(1,cad,strlen(cad));   //pintem cad per pantalla
                }

                sleep(1);
            }
    default:
            //Pare
            close(pip_fill[1]);
            close(pip_pare[0]);
            close(0);

            while(1){   

                nbytes = read(pip_fill[0],valor,strlen(valor));//el pare llegeix de la pipe la var valor 
                //WriteStr("Pare despres\n");
                if (nbytes != 0){   //vol dir que hem llegit algo per la pipe pip_fp
                    //tractem la variable valor
                    num = atoi(valor);
                    num = num*2;

                    sprintf(cad,"Valor actual de la variable: %d \n\n",num);

                    write(1,cad,strlen(cad));

                    write(pip_pare[1],cad,strlen(cad)); //el pare escriu a la pipe la var tractada
                }

                sleep(1);
            }
}
return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
无效写入（字符*指令）
{
书写（1，inStr，strlen（inStr））；
}
内部主（空）{
char*cad1=“引荐联合国的勇气：”；
int字节=0；
char valor[256]；
//根据联合国通讯社提供的联合国管道服务，
//这是必要的，因为我们需要有足够的时间，
//s'hauran d'utilitzar dos管道。
int pip_fill[2]；//pip_fp[0]：文件描述符
//pip_fp[1]：文件描述符d'descriptura
int pip_pare[2]；//pip_pf[0]：文件描述符
//pip_pf[1]：文件描述符d'descriptura
整数pid，n字节=0；
char-cad[256]；
int num=0；
if（管道（管道填充）
我想你的意思可能是
sizeof（cad）

write(1,cad,strlen(cad));

nbytes = read(pip_fill[0],valor,strlen(valor));

和
n字节

write(1,cad,strlen(cad));

nbytes = read(pip_fill[0],valor,strlen(valor));

这是类似的，但在这个版本中有一个隐藏的陷阱，我将把它作为练习留下

我想你的意思可能是
sizeof（cad）

write(1,cad,strlen(cad));

nbytes = read(pip_fill[0],valor,strlen(valor));

和
n字节

write(1,cad,strlen(cad));

nbytes = read(pip_fill[0],valor,strlen(valor));

这与此类似，但在这个版本中有一个隐藏的陷阱，我将留作练习！
当发送可变长度数据时，最好先发送长度（在固定长度整数中）这样收件人就知道要请求多少数据。
发送可变长度数据时，最好先发送长度（以固定长度整数表示），这样收件人就知道要请求多少数据。
您好，现在解决了，这是读取大小的问题。感谢这一点：）您好，它现在解决了，是阅读大小的问题。谢谢您的观点：）谢谢您的评论：）我会尝试这样做。谢谢您的评论：）我会尝试这样做。