Linked List Head getting overwritten by tail - c

Question

I am trying to get use to C by implementing different data structures. I am having an issue where when I try to initialize a linked list from command line inputs per while loop iterations, the head keeps getting set to the tail, which is the last command inputted into stdin
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct node {
char value[512];
struct node *next;
};
int main(int argc, char *argv[])
{
struct node *head = malloc(sizeof(struct node));
struct node **curr = &head;
int flag = 1;
int c = 0;
while(flag == 1)
{
char cmd[512];
struct node *new_node = malloc(sizeof(struct node));
fgets(cmd, 512, stdin);
cmd[strcspn(cmd, "\n")] = 0;
if (strcmp(cmd,"exit") ==0){
printf("Exiting\n");
break;
} else {
strncpy(new_node->value, cmd, 512);
new_node->value[512 - 1] = '\0';
(*curr)->next = new_node;
*curr = new_node;
}
}
printf("head value: %s\n", head->value);
printf("curr value: %s", (*curr)->value);
return 0;
}
I can't understand why head->value and curr->value end up being the same. Any input is appreciated along with any convention fixes. I am not sure I am writing C in the expected way.
Thanks,
I tried to use different pointer combinations, and I have also tried to copy the command line entry rather than hard setting it.

Answer 1

It is unclear whether you want to insert new nodes to the start of the list or to the end of the list.
If you want to insert new nodes to the start of the list, then you must update head after every list insertion and set the next member of the new node to the old head.
If you instead want to insert new nodes to the end of the list, then you must make curr always point to the next member of the last node of the list, or make it point to head if the list is empty.
You appear to be applying neither of the two options described above. Instead, you are making curr always point to head and making head always point to the most recently created node. You are also making the next pointer of the previous head node point to the new head node. In other words, you are making the next pointers point in the wrong direction. The next pointers should always point away from the head, not toward the head.
Here is an example program which inserts nodes at the start of the linked list:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_STRING_LENGTH 512
struct node {
char value[MAX_STRING_LENGTH];
struct node *next;
};
int main( void )
{
struct node *head = NULL;
for (;;) //infinite loop, equivalent to while(1)
{
char cmd[MAX_STRING_LENGTH];
struct node *new_node;
//read one line of input
if ( fgets( cmd, sizeof cmd, stdin ) == NULL )
{
fprintf( stderr, "Input failure!\n" );
exit( EXIT_FAILURE );
}
cmd[strcspn(cmd,"\n")] = '\0';
//check whether user wants to quit
if ( strcmp( cmd, "exit" ) == 0 )
{
printf("Exiting\n");
break;
}
//allocate new node
new_node = malloc( sizeof(struct node) );
if ( new_node == NULL )
{
fprintf( stderr, "Memory allocation failure!\n" );
exit( EXIT_FAILURE );
}
//set value of new node
strcpy( new_node->value, cmd );
//make new node point to old head
new_node->next = head;
//set head to new node
head = new_node;
}
//print content of linked list
printf( "\nThe head points to the address %p.\n", head );
for ( struct node *p = head; p != NULL; p = p->next )
{
printf(
"Node at address %p\n"
" has the value \"%s\"\n"
" and points to the address %p.\n",
(void*)p, p->value, (void*)p->next
);
}
//free the nodes
for ( struct node *p = head; p != NULL; )
{
struct node *temp = p->next;
free( p );
p = temp;
}
return 0;
}
This program has the following behavior:
node1
node2
node3
exit
Exiting
The head points to the address 0x559eea92aad0.
Node at address 0x559eea92aad0
has the value "node3"
and points to the address 0x559eea92a8c0.
Node at address 0x559eea92a8c0
has the value "node2"
and points to the address 0x559eea92a6b0.
Node at address 0x559eea92a6b0
has the value "node1"
and points to the address (nil).
Here is an example program which instead inserts nodes at the end of the linked list:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_STRING_LENGTH 512
struct node {
char value[MAX_STRING_LENGTH];
struct node *next;
};
int main( void )
{
struct node *head = NULL;
struct node **pp_next = &head;
for (;;) //infinite loop, equivalent to while(1)
{
char cmd[MAX_STRING_LENGTH];
struct node *new_node;
//read one line of input
if ( fgets( cmd, sizeof cmd, stdin ) == NULL )
{
fprintf( stderr, "Input failure!\n" );
exit( EXIT_FAILURE );
}
cmd[strcspn(cmd,"\n")] = '\0';
//check whether user wants to quit
if ( strcmp( cmd, "exit" ) == 0 )
{
printf("Exiting\n");
break;
}
//allocate new node
new_node = malloc( sizeof(struct node) );
if ( new_node == NULL )
{
fprintf( stderr, "Memory allocation failure!\n" );
exit( EXIT_FAILURE );
}
//set value of new node
strcpy( new_node->value, cmd );
//make new node point to NULL
new_node->next = NULL;
//link new node to existing list
*pp_next = new_node;
//update pp_next to point to the new NULL pointer
pp_next = &new_node->next;
}
//print content of linked list
printf( "\nThe head points to the address %p.\n", head );
for ( struct node *p = head; p != NULL; p = p->next )
{
printf(
"Node at address %p\n"
" has the value \"%s\"\n"
" and points to the address %p.\n",
(void*)p, p->value, (void*)p->next
);
}
//free the nodes
for ( struct node *p = head; p != NULL; )
{
struct node *temp = p->next;
free( p );
p = temp;
}
return 0;
}
This program has the following behavior:
node1
node2
node3
exit
Exiting
The head points to the address 0x5568056a06b0.
Node at address 0x5568056a06b0
has the value "node1"
and points to the address 0x5568056a08c0.
Node at address 0x5568056a08c0
has the value "node2"
and points to the address 0x5568056a0ad0.
Node at address 0x5568056a0ad0
has the value "node3"
and points to the address (nil).