来自父进程的C管道错误值

我有一个简单的程序，但是当我想检查我从孩子那里得到的值时，它返回1995694080或类似的数字。我有点困惑，如何才能实现味精的真正价值？看起来我从其他地方得到了一些随机的垃圾值，而我不应该这样做。我在一个教程的基础上制作了这个管道发送器，当我从孩子那里发回数据时，它大部分是有效的，但它失败了。有什么想法或建议吗

int pipefd[2];

int main()
{
    signal(SIGTERM, handler);
    signal(SIGUSR1, finishedOrder);
    pid_t pid;


    if (pipe(pipefd) == -1)
    {
        perror("Error while making pipe.\n");
        exit(1);
    }

    pid = fork();

    if (pid < 0)
    {
        perror("Fork error.\n");
        exit(1);
    }

    if (pid > 0)
    {
        employer(pid, 4, false);
    }
    else
    {
        employee(getppid());
    }
}

void employer(pid_t pid, int id, bool two)
{
    int rec;

    printf("[Szülő]: várok egy szerelő csapatra! \n");
    sleep(1);

    kill(pid, SIGTERM);

    pause();

    if (two)
    {
        /.../
    }
    else
    {
        printf("[Szülő]: dolgozz a %d. feladaton\n", id);
        close(pipefd[0]);
        write(pipefd[1], &id, sizeof(id)); //this is works.
        close(pipefd[1]);
        sleep(1);

        kill(pid, SIGTERM);

        pause();

        kill(pid, SIGTERM);
    }

    pause();

    close(pipefd[1]);
    read(pipefd[0], &rec, sizeof(rec));

    printf("%d\n", rec); // here I get the strange value

    if (rec == 4)
    {
        printf("[Szülő]: feljegyeztem a módosításokat.\n");
        if (two)
        {
            /**/
        }
        else
        {
            /**/
        }
    }

}

void employee(pid_t emp)
{
    int jobs[2];
    pause();

    printf("[Gyerek]: munkára jelentkezek\n");
    sleep(1);

    kill(emp, SIGTERM);

    pause();

    close(pipefd[1]);

    read(pipefd[0], &jobs[0], sizeof(jobs[0]));
    close(pipefd[0]);
    printf("[Gyerek]: elkezdek dolgozni a %d. feladaton.\n", jobs[0]);
    sleep(1);
    kill(emp, SIGUSR1);
    pause();

    sleep(1);
    read(pipefd[0], &jobs[1], sizeof(jobs[1]));


    if (jobs[1] != 0)
    {
        printf("[Gyerek]: elkezdek dolgozni a %d. feladaton.\n", jobs[1]);
        sleep(1);

        kill(emp, SIGUSR1);
    }

    close(pipefd[0]);
    fflush(NULL);
    int msg = 4;
    printf("%d\n", msg);
    write(pipefd[1], &msg, sizeof(msg));
    close(pipefd[1]);

    sleep(1);
    kill(emp, SIGTERM);
}

void handler(int signum)
{
}

void finishedOrder()
{
}

int-pipefd[2]；
int main（）
{
信号（SIGTERM，处理器）；
信号（SIGUSR1，finishedOrder）；
pid_t pid；
如果（管道（管道FD）=-1）
{
perror（“制作管道时出错。\n”）；
出口（1）；
}
pid=fork（）；
if（pid<0）
{
perror（“Fork错误。\n”）；
出口（1）；
}
如果（pid>0）
{
雇主（pid，4，假）；
}
其他的
{
employee（getppid（））；
}
}
无效雇主（pid\u t pid，内部id，布尔二）
{
int rec；
printf（“[Szülő]：várok egy szerelőcsapatra！\n”）；
睡眠（1）；
kill（pid，SIGTERM）；
暂停（）；
若有（二）
{
/.../
}
其他的
{
printf（“[Szülő]：dolgozz a%d.feladaton\n”，id）；
关闭（pipefd[0]）；
write（pipefd[1]，&id，sizeof（id））；//这很有效。
关闭（pipefd[1]）；
睡眠（1）；
kill（pid，SIGTERM）；
暂停（）；
kill（pid，SIGTERM）；
}
暂停（）；
关闭（pipefd[1]）；
读取（pipefd[0]，&rec，sizeof（rec））；
printf（“%d\n”，rec）；//这里我得到一个奇怪的值
如果（rec==4）
{
printf（“[Szülő]：feljegyeztem a módosításokat.\n”）；
若有（二）
{
/**/
}
其他的
{
/**/
}
}
}
无效员工（pid_t emp）
{
国际就业[2]；
暂停（）；
printf（“[Gyerek]：munkára jelentkezek\n”）；
睡眠（1）；
杀死（emp、SIGTERM）；
暂停（）；
关闭（pipefd[1]）；
读取（pipefd[0]、&jobs[0]、sizeof（jobs[0]）；
关闭（pipefd[0]）；
printf（“[Gyerek]：elkezdek dolgozni a%d.feladaton.\n”，作业[0]）；
睡眠（1）；
杀死（emp，SIGUSR1）；
暂停（）；
睡眠（1）；
读取（pipefd[0]，&jobs[1]，sizeof（jobs[1]）；
如果（作业[1]！=0）
{
printf（“[Gyerek]：elkezdek dolgozni a%d.feladaton.\n”，jobs[1]）；
睡眠（1）；
杀死（emp，SIGUSR1）；
}
关闭（pipefd[0]）；
fflush（空）；
int msg=4；
printf（“%d\n”，msg）；
写入（pipefd[1]，&msg，sizeof（msg））；
关闭（pipefd[1]）；
睡眠（1）；
杀死（emp、SIGTERM）；
}
无效处理程序（int-signum）
{
}
void finishedOrder（）
{
}

您不会检查

read

返回的值来查看您收到了多少数据。如果您这样做了，您可能会发现这并不是您所期望的，因为在您的代码的前面，您已经这样做了

    close(pipefd[0]);

关闭文件描述符后，无法读取它。更重要的是，您创建的“管道”不是双向的。如果要发送和接收，需要对

pipe

进行两次调用，以获取两对文件描述符

鉴于您在读取之前也执行了

关闭（pipefd[1]）

，这意味着您已经关闭了管道的两端，因此您似乎误解了

关闭的目的。子级和父级
关闭他们未使用的管道的末端-仅此而已。这并不意味着是谁在给管道读或写

您不会检查
read
返回的值来查看您收到了多少数据。如果您这样做了，您可能会发现这并不是您所期望的，因为在您的代码的前面，您已经这样做了

    close(pipefd[0]);

关闭文件描述符后，无法读取它。更重要的是，您创建的“管道”不是双向的。如果要发送和接收，需要对
pipe
进行两次调用，以获取两对文件描述符

鉴于您在读取之前也执行了
关闭（pipefd[1]）
，这意味着您已经关闭了管道的两端，因此您似乎误解了
关闭的目的。子级和父级
关闭他们未使用的管道的末端-仅此而已。它并不表示谁在向管道读写任何信息。
在
employer（）
函数中，使用
close（pipefd[0]）关闭管道的读取端
然后稍后尝试使用
read（pipefd[0]，&rec，sizeof（rec））从中读取

试图从关闭的fd读取可能会导致奇怪的值。我会照约翰纳森·莱夫勒说的做

rustyx在注释中是正确的-检查
read（）
的返回值是个好主意，因为它会发现这种错误。
在
employer（）
函数中，使用
close（pipefd[0]）关闭管道的读取端
然后稍后尝试使用
read（pipefd[0]，&rec，sizeof（rec））从中读取

试图从关闭的fd读取可能会导致奇怪的值。我会照约翰纳森·莱夫勒说的做

rustyx在注释中是正确的-检查
read（）
的返回值是个好主意，因为它会发现这种错误。
也许
read
没有成功？如果忽略它的返回值，您怎么知道呢？可能
read
没有成功？如果忽略其返回值，您怎么知道呢？从关闭的fd读取只会导致读取很快失败-返回值为-1，错误号为EBADF。它不会修改传递来保存数据的数组。代码没有，但应该检查读取和写入的返回值。从关闭的fd读取只会导致读取很快失败-返回值为-1，错误号为EBADF。它不会修改传递来保存数据的数组。代码不检查，但应该检查读取和写入的返回值。