将字符串添加到链表会导致段错误

Question

I am trying to add strings that I am reading from a text file to a linked list. Since I don't know how long the file or the string is , I want to do this dynamically. But somewhere along the line I get a segmentation fault. I have tried everything but I think I overlooked something crucial. Could someone tell me what I am doing wrong?

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

typedef struct node {
        char *name;
        int age;
        struct node* next;
    }node;


node *add(node *head, char* n_m){
   node *new_node;
   new_node = (node*)malloc(sizeof(node));
   if(new_node == NULL)
      printf("Fehler bei Speicher reservierung...");
   new_node->name = (char*)malloc(100*sizeof(char));
   if(new_node->name == NULL)
      printf("Fehler bei Speicher reservierung...");

   strcpy(new_node->name, n_m);


   if(head == NULL){
      head = new_node;
      head->next = NULL;
      return head;
   }

   node *current;
   current = head;

   while(current->next != NULL){
      current = current->next;
   }

   current->next = new_node;
   new_node->next = NULL;
   return head;
 }

 void print(node *head){
   node *current;
   current = head;

   while(current != NULL){
     printf("%s\n", current->name);
     current = current->next;
    }
   }

int main(){

  node *head = NULL;

  char character;

  FILE *fp;
  fp = fopen("test.txt", "r");

  while ((character = fgetc(fp)) != EOF) {
  char *n_m;
  n_m = (char*)malloc(100 * sizeof(char));
  if(n_m == NULL)
     printf("Fehler bei Speicher reservierung...");


  int i = 0;
  while (character != ' ') {
     n_m[i++] = character;
     character = fgetc(fp);
  }
  n_m[++i] = '\0';   // NULL-terminate

  head = add(head, n_m);   

  free(n_m);

 }
 print(head);
 return 0;
}

Answer 1

You need to guard against reading beyond the end of file and against going beyond the memory you've allocated. It may also be possible that your file had a "long line" right at 100 characters by both postfixing and prefixing i you went passed your end of buffer.

  while ((character = fgetc(fp)) != EOF) {
      char *n_m;
      n_m = (char*)malloc(100 * sizeof(char));
      if(n_m == NULL)
          printf("Fehler bei Speicher reservierung...");
      int i = 0;
      while ((character != ' ') 
         &&  (character != EOF)
         &&  (i < 100)) {
          n_m[i++] = character;
          character = fgetc(fp);
          }
      // don't postfix add about then prefix add below
      if (i >= 100) {
         … there is a problem …
          }   
      n_m[i] = '\0';   // NULL-terminate
      head = add(head, n_m);
      free(n_m);
      }

You might consider something more like this

  #define BUFF_SIZE 100  
  char buff[BUFF_SIZE];
  buff[0] = '\0';
  int i = 0;
  while (((character = fgetc(fp)) != EOF) 
     &&  (i < BUFF_SIZE)) {
      buff[i++] = character;
      character = fgetc(fp);
      if (character = ' ') {
          buff[i] = '\0';   // NULL-terminate
          head = add(head, buff);   
          i = 0;
          buff[0] = '\0';
          }
      }
   if (i >= BUFF_SIZE) { … there is a problem … }

This does a couple of useful things. One is your buffer is statically allocated and it's size is controlled by a single #define. Second, it reduces the number of loops involved which can improve readability.

Answer 2

Your biggest issue is your read of characters does not trap EOF and will continue reading after EOF is encountered, causing i to exceed your array bounds invoking Undefined Behavior leading to your SegFault. The code in question is:

  while (character != ' ') {
     n_m[i++] = character;
     character = fgetc(fp);
  }

Since POSIX files do not end with a ' ' (space), but instead a '\\n' , your read of the last word in the file does not stop at EOF . You further have problems with multiple spaces together repeatedly writing nodes containing the empty-string to your list.

You also fail to handle any other whitespace other than space , meaning you are including '\\t' , '\\n' , vertical tab , etc.. within the words you store. Instead of checking space with ' ' , use the isspace() macro included in ctype.h .

n_m[++i] = '\\0'; should be n_m[i] = '\\0'; . You increment i with n_m[i++] = character; . You do NOT want to increment i again with the pre-increment operator before nul-terminating your string. That results in the last character in the string being indeterminate (again invoking undefined behavior when a read of the string is attempted)

Fixing those issues (and using c instead of character , ndx instead of i and buf instead of n_m ), your read and add() to your list would resemble:

    while ((c = fgetc(fp)) != EOF) {            /* read each char in file */
        if (isspace(c) || ndx == MAXC - 1) {    /* is space or buf full? */
            if (in) {                           /* were we within word? */
                buf[ndx] = 0;                   /* nul-terminate */
                head = add (head, buf);         /* add node to list */
            }
            if (ndx < MAXC - 1)     /* buffer not full */ 
                in = 0;             /* set in flag zero */
            ndx = 0;                /* reset index zero */
        }
        else {  /* otherwise */
            buf[ndx++] = c;         /* add char to buf */
            in = 1;                 /* set in flag 1 */
        }
    }

( note: using the variable in as an in/out flag to keep track of whether you are within a word reading characters, or between words reading whitespace solves the problem you would have with multiple whitespace characters in sequences, eg "hello world" )

Optional, but helpful, when allocating nodes that also contain members that need to be allocated is to write a createnode() function that fully Allocates and Initializes all node members rather than putting that code in add() . It keeps things clean and ensures every node you allocate is fully initialized before its use in add() . For example:

/** create new node, allocate and initialize all member values,
 *  return pointer to node on success, NULL otherwise.
 */
node *createnode (char *s)
{
    node *new_node;

    new_node = malloc (sizeof *new_node);       /* allocate/validate node */
    if (new_node == NULL) {
        perror ("malloc-Fehler bei Speicher reservierung...");
        return NULL;
    }

    new_node->name = malloc (strlen (s) + 1);   /* allocate/validate name */
    if (new_node->name == NULL) {
        perror ("malloc-Fehler bei Speicher reservierung...");
        return NULL;;
    }

    strcpy (new_node->name, s);     /* initialize all node values */
    new_node->age = 0;
    new_node->next = NULL;

    return new_node;    /* return newly allocated/initialized node */
}

Then your add() function reduces to:

/** add node containing allocated string 'n_m' to list, return pointer
 *  to 1st node in list on success, exit with failure otherwise.
 */
node *add (node *head, char *n_m)
{
    node *new_node = createnode (n_m);  /* allocate/initialize new node */
    node *current = head;               /* pointer to current head */

    if (new_node == NULL)               /* validate allocation */
        exit (EXIT_FAILURE);

    if (!head)                          /* handle 1st node */
        return new_node;

    while (current->next != NULL)       /* iterate to end of list */
        current = current->next;

    current->next = new_node;           /* set next node to new_node */

    return head;                        /* return pointer to head */
}

Putting it altogether and adding a del_list() function to free all allocated memory for the list, you could do the following:

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

#define MAXC 1024

typedef struct node {
    char *name;
    int age;
    struct node *next;
} node;

/** create new node, allocate and initialize all member values,
 *  return pointer to node on success, NULL otherwise.
 */
node *createnode (char *s)
{
    node *new_node;

    new_node = malloc (sizeof *new_node);       /* allocate/validate node */
    if (new_node == NULL) {
        perror ("malloc-Fehler bei Speicher reservierung...");
        return NULL;
    }

    new_node->name = malloc (strlen (s) + 1);   /* allocate/validate name */
    if (new_node->name == NULL) {
        perror ("malloc-Fehler bei Speicher reservierung...");
        return NULL;;
    }

    strcpy (new_node->name, s);     /* initialize all node values */
    new_node->age = 0;
    new_node->next = NULL;

    return new_node;    /* return newly allocated/initialized node */
}

/** add node containing allocated string 'n_m' to list, return pointer
 *  to 1st node in list on success, exit with failure otherwise.
 */
node *add (node *head, char *n_m)
{
    node *new_node = createnode (n_m);  /* allocate/initialize new node */
    node *current = head;               /* pointer to current head */

    if (new_node == NULL)               /* validate allocation */
        exit (EXIT_FAILURE);

    if (!head)                          /* handle 1st node */
        return new_node;

    while (current->next != NULL)       /* iterate to end of list */
        current = current->next;

    current->next = new_node;           /* set next node to new_node */

    return head;                        /* return pointer to head */
}

void print (node * head)
{
    node *current;
    current = head;

    while (current != NULL) {
        printf ("%s\n", current->name);
        current = current->next;
    }
}

/** delete all nodes in list */
void del_list (node *head)
{
    node *pn = head;                /* pointer to iterate */

    while (pn) {                    /* iterate over each node */
        node *victim = pn;          /* set victim to current */
        pn = pn->next;              /* advance pointer to next */
        free (victim->name);        /* free current string */
        free (victim);              /* free current node */
    }
}

int main (int argc, char **argv) {

    char buf[MAXC];
    int c = 0, in = 0, ndx = 0;
    node *head = NULL;
    /* use filename provided as 1st argument (stdin by default) */
    FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;

    if (!fp) {  /* validate file open for reading */
        perror ("file open failed");
        return 1;
    }

    while ((c = fgetc(fp)) != EOF) {            /* read each char in file */
        if (isspace(c) || ndx == MAXC - 1) {    /* is space or buf full? */
            if (in) {                           /* were we within word? */
                buf[ndx] = 0;                   /* nul-terminate */
                head = add (head, buf);         /* add node to list */
            }
            if (ndx < MAXC - 1)     /* buffer not full */ 
                in = 0;             /* set in flag zero */
            ndx = 0;                /* reset index zero */
        }
        else {  /* otherwise */
            buf[ndx++] = c;         /* add char to buf */
            in = 1;                 /* set in flag 1 */
        }
    }
    if (fp != stdin)        /* close file if not stdin */
        fclose (fp);

    print (head);           /* print list */
    del_list (head);        /* free all allocated memory */
}

Example Input File

$ cat dat/captnjack.txt
This is a tale
Of Captain Jack Sparrow
A Pirate So Brave
On the Seven Seas.

Example Use/Output

$ ./bin/ll_name_age dat/captnjack.txt
This
is
a
tale
Of
Captain
Jack
Sparrow
A
Pirate
So
Brave
On
the
Seven
Seas.

Memory Use/Error Check

In any code you write that dynamically allocates memory, you have 2 responsibilities regarding any block of memory allocated: (1) always preserve a pointer to the starting address for the block of memory so, (2) it can be freed when it is no longer needed.

It is imperative that you use a memory error checking program to ensure you do not attempt to access memory or write beyond/outside the bounds of your allocated block, attempt to read or base a conditional jump on an uninitialized value, and finally, to confirm that you free all the memory you have allocated.

For Linux valgrind is the normal choice. There are similar memory checkers for every platform. They are all simple to use, just run your program through it.

$ valgrind ./bin/ll_name_age dat/captnjack.txt
==18265== Memcheck, a memory error detector
==18265== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==18265== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==18265== Command: ./bin/ll_name_age dat/captnjack.txt
==18265==
This
is
a
tale
Of
Captain
Jack
Sparrow
A
Pirate
So
Brave
On
the
Seven
Seas.
==18265==
==18265== HEAP SUMMARY:
==18265==     in use at exit: 0 bytes in 0 blocks
==18265==   total heap usage: 35 allocs, 35 frees, 6,132 bytes allocated
==18265==
==18265== All heap blocks were freed -- no leaks are possible
==18265==
==18265== For counts of detected and suppressed errors, rerun with: -v
==18265== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Always confirm that you have freed all memory you have allocated and that there are no memory errors.

Look things over and let me know if you have further questions.