4

编辑:因此,通过一些额外的调试,EOF已成功写入管道(我知道这一点,因为我测试以确保该write()函数在produceStdin.好)但EOF元素的值等于255(而不是像通常那样的-1)。有谁知道为什么会这样???

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

除了在函数中打印数组之外的所有打印语句printOut()都是我试图调试它(由于分叉而无法使用调试器)

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

这是代码:

#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);
}
4

2 回答 2

2

Alternative 传递通过管道读取的内容的 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 不适合char.

// 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))) {

于 2013-10-15T19:55:02.820 回答
0

这个位在编写代码中是有问题的:

int c = 0;

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

你应该使用:

int c;

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

from 的输出fgetc()是作为 anint或 EOF 返回的无符号字符值。实际上,您检测到 EOF,然后将一个字节写入管道,该字节确实不应该写入。一般情况下需要使用c1;您可能会逃脱在小端机器上编写的内容,但它在大端机器上无法正常工作。您可能也应该检查写入是否成功。

等效阅读代码也有类似的问题。你有:

int c=0;
while(c!=EOF)
{
    read(readPipe,&c,sizeof(char));
    if(c=='\n')
    {
        c=' '; //test for newline
    }
    write(writePipe, &c, sizeof(char));
}

你需要:

char c;
while (read(readPipe, &c, sizeof(char)) == sizeof(char))
{
    if (c == '\n')
        c = ' ';
    write(writePipe, &c, sizeof(char));
}

再次,有 little-endian 与 big-endian 的可移植性问题,以及输入操作的测试(总是,但总是检查输入操作;你经常可以不检查输出就逃脱,但你必须总是检查输入) .

请注意,单字符 I/O 通过read()write()对于高性能应用程序来说是昂贵的。标准 I/O 单字符 I/O 是可以的,因为它缓冲输入或输出,并且不会在每次读取和每次写入时调用系统调用的开销。对于玩具应用程序,您不会注意到开销。

这很可能是chux在他的回答中所说的,表达方式略有不同。

于 2013-10-15T21:15:31.557 回答