Question

我正在尝试编写一个由一个字符数组，一个整数值和一个指向管道的指针组成的结构。该结构表示单链表中的节点。

//Define a linked-list node object
typedef struct node{
    char word[128];
    int frequency;
    struct node *next;
} NODE;

该程序的目标是使用管道将节点从几个并发子进程传递给父进程。我实现的管道结构似乎可以正常使用常规字符数组，但如果我尝试传递整个节点对象则无法工作。

    //for each file argument, create a child process
        for (i = 1; i < argc; i ++)
        {
            pipe(p[i-1]);
            pid = fork();

            if (pid == 0)
            {
                //child process
                close(p[i-1][0]);
                NODE *tmp;
                NODE *out = freqCheck(argv[i], tmp);
                write(p[i-1][1], out, sizeof(NODE));
                exit(0);
            }
        }
if (pid > 0){
                //parent process
                int j;
                for (j = 0; j < argc-1; j++)
                {
                    close(p[j][1]);
                    NODE *tmp;
                    read(p[j][0], tmp, sizeof(NODE));

                    printf("%s\n", tmp->word);
                }


            }

当父进程尝试从管道读取并解释结构的一个属性时，我只会返回空值。

我正在使用一个包含2个元素整数数组的数组来跟踪每个子进程的管道。上面的printf语句返回null revery time。

知道我做错了吗？

FrqCheck方法的代码：

//Method for determining the most occuring word
NODE * freqCheck(char *file, NODE *max)
{
    int i; 
    FILE *f;
    char str[128];

    //Set up head and tail nodes
    NODE *head = NULL;
    NODE *tail = NULL;

    if ((f = fopen(file, "r")) == NULL)
        {
            //sprintf(output, "%s could not be opened.", file);
        }else
        {
            //scan each word of the input file
            while(fscanf(f, "%s ", str) != EOF)
            {
                //if the linked-list has no nodes, create one
                if (head == NULL)
                {
                    NODE *n;
                    n = (NODE *)malloc(sizeof(NODE));
                    strcpy(n->word, str);
                    n->frequency = 1;
                    n->next = NULL;
                    head = n;
                    tail = n;

                }else{  //search the linked list for the found word.

                    NODE *current = head;
                    int found = 0;

                    while((current != NULL) && (found == 0))
                    {
                        //if the word is found increment the frequency
                        if (strcmp(current->word, str) == 0)
                        {
                            current->frequency ++;
                            found = 1;
                        }else
                        {
                            current = current->next;
                        }
                    }

                    //if the word is not found, create a node and add to the liked-list
                    if (found == 0)
                    {
                        NODE *new;
                        new = (NODE *)malloc(sizeof(NODE));
                        strcpy(new->word, str);
                        new->frequency = 1;
                        new->next = NULL;
                        tail->next = new;
                        tail = new;
                    }
                }
            }
            //traverse the linked-list and find the word with the maximum frequency
            NODE *tmp = head;
            max = tmp;

            while (tmp != NULL)
            {
                if (tmp->frequency > max->frequency)
                {
                    max = tmp;
                }else
                {
                    tmp = tmp->next;
                }
            }
            //sprintf(output, "%s %s %d", file, max->word, max->frequency);
        }
    //printf("%s\n", max->word);
    return max;
}

Answer 1

您在哪里为NODE结构分配存储空间？ freqCheck是否分配存储空间？在父进程中，当您调用read()然后调用printf时，会传入未初始化的NODE指针，因此您当然会收到未定义的行为。

Answer 2

使用缓冲读取读取数据直到读取整个结构，因为来自父级的代码可以在来自子级的代码之前执行，然后读取不存在的数据。

Answer 3

你需要考虑两件事：
1）执行协调：

这就是锁，信号量，事件等等。他们对指令（您的代码行）的运行顺序执行订单。正是出于这个原因，有些版本可以在进程之间运行，就像为线程运行一样。你想要一个信号量 - 编写器进程应该在节点完全传输时post（）sem，读取器进程应该在sem上等待（），然后再尝试读取下一个节点。

2）记忆：
进程不共享地址空间。因此，读者和作者过程中的堆是不同的ram块。管道工作正常，但它就像一个套接字 - 你将对象序列化和反序列化为原始字节流是非常糟糕的。考虑到你的结构有多小，你可以考虑的另一件事是共享内存。

最后要考虑的事情是：您需要在子进程中更新指向节点结构中“下一个”节点的指针。同样，它将把这些节点复制到它自己的地址空间中的位置，因此必须相应地更新“下一个”指针。

在C中读取和写入管道的结构

3 个答案: