Calculates values ​​from a text file in C

Since your problem is a very good candidate for optimizing memory fragmentation, here is an implementation that uses some simple magic to allocate all strings and the structure itself to one piece of memory.

When destroying a node, you only need one call free()

, node itself.

struct Node *list = NULL, **nextp = &list;
char buffer[1024];

while (fgets(buffer, sizeof buffer, file) != NULL) {
    struct Node *node;

    node = malloc(sizeof(struct Node) + strlen(buffer) + 1);
    node->key = strtok(strcpy((char*)(node+1), buffer), "/\r\n");
    node->value = strtok(NULL, "\r\n");
    node->next = NULL;
    *nextp = node;
    nextp = &node->next;
}

      

        
        
        
      

    

Explanation:

With 20 comments and one unexplained top-down one, I believe the code needs some explanation, especially regarding the tricks used:

• Creating a linked list:

  struct Node *list = NULL, **nextp = &list;
  ...
  *nextp = node;
  nextp = &node->next;
  
        
  
          
          
          
        
  
      

  This is a trick to create a linked list iteratively in a forward order without resorting to a special list header. It uses a pointer to a pointer to the next node. The pointer first nextp
  
  points to the list header pointer; in the first iteration, the head of the list is set through this pointer to the pointer, and then nextp
  
  moves to the next pointer of this node. Subsequent iterations fill the next pointer to the last node.

• Single placement:

  node = malloc(sizeof(struct Node) + strlen(buffer) + 1);
  node->key = ... strcpy((char*)(node+1), buffer) ...
  
        
  
          
          
          
        
  
      

  We need to deal with three pointers: the node itself, the key string, and the value string. This will usually require three separate allocations (malloc, calloc, strdup ...) and hence free separate releases (free). Instead, in this case, the tree element spaces are summed in sizeof(struct Node) + strlen(buffer) + 1
  
  and passed to a single call malloc
  
  , which returns one block of memory. The beginning of this block of memory is assigned node
  
  to the structure itself. Additional memory (strlen (buffer) +1) appears immediately after node and its address is obtained using pointer arithmetic with node+1
  
  . It is used to copy the entire line read from the file ("key / value \ n").

  Since it malloc
  
  is called a single time for each node, one allocation is performed. This means that you don't need to call free(node->key)
  
  and free(node->value)
  
  . It won't actually work. Only one free(node)
  
  will take care of freeing the structure and both lines in the same block.

• Parsing strings:

  node->key = strtok(strcpy((char*)(node+1), buffer), "/\r\n");
  node->value = strtok(NULL, "\r\n");
  
        
  
          
          
          
        
  
      

  The first call strtok
  
  returns a pointer to the beginning of the buffer itself. It looks for "/" (optional for end-of-line markers) and splits the line there with a NUL character. Thus, "key / value \ n" is split into "key" and "value \ n" with a NUL character in between, and a pointer to the first is returned and stored in node->key
  
  . The second call strtok
  
  will work on the remaining "value \ n", strip the end-of-line marker and return the pointer to the "value" that is stored in node->value
  
  .

Hopefully this clears up all the questions about the above solution ... this is too much for a closed question. Full test code here .