使用静态节点每个文件描述符读取 1 行

Question

我正在尝试一次读取一行文件，具有不同的缓冲区长度。我将文件 desc 传递给 get_next_line 函数并将该行分配给指针。问题是当缓冲区长度很长时，有时它会打印文件的其余部分，当我传递 2 个不同的文件描述符时，我得到一个段错误。我认为这与将字符串保存在节点中并在 fd 相同时找到相同的节点有关。 我没有看到我在这里做错了什么。

get_next_line.c

#include "get_next_line.h"
#include <fcntl.h>
#include <stdio.h>

/*
 ** CREATE THE NEXT NODE TO ADD TO THE LINKEDLIST.
 **
 */
t_node *create_node(char *buffer, int fd)
{
    int i;
    t_node *new;

    i = 0;
    while (*buffer != '\n')
        buffer++;
    if (*buffer == EOF)
        return 0;
    ++buffer;
    new = malloc(sizeof(t_node));
    new->fd = fd;
    new->next = NULL;
    new->str = malloc(sizeof(char *));
    while (buffer[i] != '\n')
    {
        new->str[i] = (char)malloc(sizeof(char));
        new->str[i] = buffer[i];
        i++;
    }
    return (new);
}

/*
 ** SEARCH THE LIST FOR FD AND GET THE OVERFLAP STRING FROM
 ** LAST READ.
 */
char *get_overlap(t_node **root, int fd)
{
    t_node *conductor;

    if (*root == NULL)
        return (NULL);

    conductor = *root;
    while (conductor->fd != fd && conductor != 0)
        conductor = conductor->next;
    if (conductor == NULL)
        return (NULL);
    return (conductor->str);
}

/*
 ** CALL THE CREATE NODE FUNCTION AND ADD IT TO THE  LINKEDLIST.
 **
 */
void save_overlap(char buffer[], t_node **root, int fd)
{
    t_node **conductor;
    t_node *new;

    new = create_node(buffer, fd);
    if (*root == NULL)
        *root = new;
    else
    {
        conductor = root;
        while (*conductor != NULL)
        {
            if ((*conductor)->fd == fd)
            {
                (*conductor)->str = new->str;
                break;
            }
            if ((*conductor)->next == NULL)
            {
                (*conductor)->next = new;
                break;
            }
            *conductor = (*conductor)->next;
        }
    }
}

/*
 ** PREPEND THE PREVIOUS OVERLAP IN BUFFER TO LINE STRING.
 **
 */
void prepend_overlap(char *str, char ***line, int *i)
{
    int b = *i;
    while (str[b])
    {
        (**line)[b] = (char)malloc(sizeof(char));
        (**line)[b] = str[b];
        b++;
    }
    *i = b;
}


/*
 ** GET A SINGLE LINE AT A TIME FROM A FILE
 ** WHILE ALSO KEEPING TRACK OF THE FD.
 */
int get_next_line(const int fd, char **line)
{
    char buffer[BUFF_SIZE + 1];
    int i;
    int j;
    char *overlap_str;
    static t_node *root;

    i = 0;
    j = 0;
    overlap_str = get_overlap(&root, fd);
    if(overlap_str != NULL)
        prepend_overlap(overlap_str, &line, &i);
    read(fd, buffer, BUFF_SIZE);
    while (buffer[j] != '\n')
    {
        if (j == BUFF_SIZE)
        {
            (*line)[i] = (char)malloc(sizeof(char));
            (*line)[i] = buffer[j];
            j = 0;
            read(fd, buffer, BUFF_SIZE);
            continue;
        }
        (*line)[i] = (char)malloc(sizeof(char));
        (*line)[i] = buffer[j];
        i++;
        j++;
    }
    (*line)[i] = '\0';
    printf("%s\n", *line);
    save_overlap(buffer, &root, fd);
    return (0);
}

int main()
{
    int fd = open("test", O_RDONLY);
    //int fdt = open("test2", O_RDONLY);
    char *line;

    get_next_line(fd, &line);
    get_next_line(fd, &line);

}

get_next_line.h

#ifndef GET_NEXT_LINE_H
# define GET_NEXT_LINE_H

# define BUFF_SIZE 32
#include <fcntl.h>

int get_next_line(const int fd, char **line);

typedef struct s_node
{
    int fd;
    char *str;
    struct s_node *next;
}t_node;

#endif

它适用于单个文件描述符，例如，我可以只传递 fd 而不是 fdt，它会起作用，除非我将缓冲区大小设置为 120 或更大，例如，它会打印出我想要的更多。我只想要'\n'之前的那一行。

Answer 1

new->str = malloc(sizeof(char *));
...
new->str[i] = (char)malloc(sizeof(char));

我不确定您要在这里做什么。 malloc(N * sizeof(char*)) 可用于创建指向“字符数组”的指针数组，大小为N。这基本上是“字符串数组”或“二维字符数组”。

malloc(sizeof(char)) 只是malloc(1)，或者只是一个字节。如果new->str 是一个字符数组，那么str[i] 已经是一个字节，不应该用malloc 设置

这样做是为了分配一个字符数组：

new->str = malloc(5);
strcpy(new->str, "1234");

这将为str分配5个字节，然后将“1234”复制到其中，并在末尾添加一个零，总共5个字节。

你的链表也没有头。请尝试以下代码。

#include <stdlib.h>//*** don't forget the right header files
#include <stdio.h>
#include <string.h>

typedef struct s_node
{
    char *str;
    struct s_node *next;
}t_node;

void insert_node(t_node** head, char* buf)
{
    t_node *node = malloc(sizeof(t_node));
    node->next = 0;

    //allocate memory for string and copy
    node->str = malloc(strlen(buf) + 1); //+1 for nul-terminator
    strcpy(node->str, buf);

    if (*head == 0)
    {
        *head = node;
    }
    else
    {
        //find the end of the linked list
        t_node *tail = *head;
        while (tail->next)
            tail = tail->next;

        //make the end element point to new node
        tail->next = node;
    }
}

int main()
{
    FILE *fd = fopen("test.txt", "r");
    if (!fd)
    {
        printf("file error\n");
        return 0;
    }

    //linked list identifier:
    t_node *head = 0;

    char buf[1000];

    //read the file line by line
    while(fscanf(fd, "%999s", buf) > 0)
    {
        //insert line in to linked list
        insert_node(&head, buf);
    }

    //show the result of the linked list:
    t_node *walk = head;
    while (walk)
    {
        printf("[%s]\n", walk->str);
        walk = walk->next;
    }

    return 0;
}

请注意，如果一行或多行的长度超过 1000 个字符，则上述代码将失败。您可以增加缓冲区长度，或者有一些方法可以解决这个问题，但我保留它是为了使示例简单。

确保编译器警告级别为 4 或最高，并确保处理所有警告和错误。