c – 管道上的EOF正在打印垃圾

2023年5月1日 209次阅读

编辑：所以通过一些额外的调试,EOF成功写入管道(我知道这是因为我测试了以确保write()函数在produceStdin上返回0.但是当从同一个管道读取时,它说我’我遇到了EOF(好),但EOF元素的值等于255(而不是像通常那样的-1).有谁知道为什么会这样？

我正在尝试编写这个程序,但是当我从stdin遇到EOF时,它并没有在管道中写入-1.无论出于何种原因,当试图通过管道传递EOF时,垃圾被写入,因此所有后续进程都被无限循环捕获.

除了在printOut()函数中打印数组的那些打印语句之外的所有打印语句都是我试图调试它(因为forks而无法使用调试器)

另外：其中一些评论被回收,所以如果你看到提到“缓冲区”,那是因为
这是先前使用缓冲而不是管道编程的.

这是代码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

#define MAX_CHARS 81 //80 chars + null-terminator
#define NUM_CHILDREN 3

void produceStdin(int writePipe);
void child1(int readPipe, int writePipe);
void child2(int readPipe, int writePipe);
void printOut(int readPipe);

int main(int argc, char const *argv[])
{
    int i,pipe1[2],pipe2[2],pipe3[2];
    pid_t childPid;

    if(pipe(pipe1)==-1||pipe(pipe2)==-1||pipe(pipe3)==-1)
    {
        fprintf(stderr, "Error in creating pipe");
    }
    //despite what it looks like only four children are being forked,
    // all to the same parent. The children get called to their respective 
    //functions where they get terminated before getting to fork themselves.
    for(i=0;i<NUM_CHILDREN;i++)
    {
        childPid=fork();
        switch (childPid) {
            case -1:
                perror("fork() failed. Aborting.");
                exit(EXIT_FAILURE);

            case 0:
                switch (i) {
                    case 0:
                        close(pipe1[0]); //close pipe1 read (since we're reading from stdin)

                        close(pipe2[0]); //close pipe2
                        close(pipe2[1]);

                        printf("right before calling stdin i=%d\n",i);
                        produceStdin(pipe1[1]); //write to pipe1
                        break;

                    case 1:
                        close(pipe1[1]); //close pipe1 write

                        close(pipe2[0]); //close pipe2 read

                        close(pipe3[0]); //close pipe3
                        close(pipe3[1]);
                        printf("right before calling child1 i=%d\n",i);
                        child1(pipe1[0], pipe2[1]); //read from pipe1, write to pipe2
                        break;

                    case 2:
                        close(pipe1[0]); //close pipe1
                        close(pipe1[1]);

                        close(pipe2[1]); //close pipe2 write

                        close(pipe3[0]); //close pipe3 read
                        printf("right before calling child2 i=%d\n",i);
                        child2(pipe2[0], pipe3[1]); //read from pipe2, write to pipe3
                        break;

                    default:
                        break;
                }

            default:
                if(i==2)
                {
                    close(pipe1[1]); //close pipe1
                    close(pipe1[0]);

                    close(pipe2[1]); //close pipe2
                    close(pipe2[0]);

                    close(pipe3[1]); //close pipe3 write

                    printOut(pipe3[0]); //read from pipe3 read
                }
                break;
        }
    }
    return 0;
}
void produceStdin(int writePipe)
{
    int c=0;
    while(c!=EOF)
    {
        c=fgetc(stdin);
        write(writePipe, &c, sizeof(char)); //writing EOF here is where the problem starts I believe
    }
    printf("Got EOF in ProdStdin\n");
    printf("EOF has a value of: %d",c);
    exit(0);
}
void child1(int readPipe, int writePipe)
{
    int c=0;
    while(c!=EOF)
    {
        read(readPipe,&c,sizeof(char));
//        printf("Child1 got a char from pipe1: %c\n",c);
        if(c=='\n')
        {
            c=' '; //test for newline
        }
        write(writePipe, &c, sizeof(char));
    }
    exit(0);
}
void child2(int readPipe, int writePipe)
{
    int c=0;
    int c2=0;
    while(c!=EOF && c2!=EOF)
    {
        read(readPipe, &c, sizeof(char));
//        printf("Child2 got a char from pipe2: %c\n",c);
        if(c=='*')
        {
            read(readPipe, &c2, sizeof(char)); //if c is a * remove another char
            if(c2=='*')
            {
                c='^'; //if c2 is a * then put a ^ on buffer3
                write(writePipe,&c,sizeof(char));
            }
            else
            {
                write(writePipe,&c,sizeof(char));
                write(writePipe,&c2,sizeof(char));
            }
        }
        else
        {
            write(writePipe,&c,sizeof(char));
        }
    }
    exit(0);
}
void printOut(int readPipe)
{
    int c=0,numChars=0;
    char output[MAX_CHARS];
    while (c!=EOF)
    {
        read(readPipe, &c, sizeof(char));
//        printf("PrintOut got a char from pipe3: %c\nnumChars= %d\n",c,numChars);
        if (numChars==MAX_CHARS-2)
        {
            printf("%s\n",output);
            memset(output, '\0', sizeof(char)*MAX_CHARS);
            numChars=0;
        }

        output[numChars]=c;
        numChars++;
    }
    printf("ABOUT TO EXIT PRINTOUT()\n");
    exit(0);
}

最佳答案 替代传递通过管道读取的2字节版本,因此接收端可以区分char和EOF.

int c = 0;
while(c!=EOF) {
  c = fgetc(stdin);
  short sc = (short) c;
  // `sc` will _typically_ have the values -1 (EOF) and 0,1,2,... 255.
  write(writePipe, &sc, sizeof(sc));
}

int c=0;
int c2=0;
while(c != EOF && c2 != EOF) {
  short sc;          
  if (sizeof(sc) != read(readPipe, &sc, sizeof(sc))) handle_error();
  // `sc` will _typically_ have the values -1 (EOF) and 0,1,2,... 255.
  c = sc;
  ...

原始建议答案.

在读完所有字符之前,c不会变为EOF.
使用：

// while(c!=EOF) {
//   c=fgetc(stdin);
//   write(writePipe, &c, sizeof(char));
// }
while((c = fgetc(stdin)) != EOF) {
  write(writePipe, &c, sizeof(char));
}

read的返回值(readPipe,& c,sizeof(char));应该评估而不是寻找c成为EOF. EOF不适合焦炭.

// int c=0;
// int c2=0;
// while(c!=EOF && c2!=EOF) {
//    read(readPipe, &c, sizeof(char));

char c=0;
char c2=0;
while(1 == read(readPipe, &c, sizeof(char))) {
点赞