Pushing item to a linked list (C) - c

Question

I am currently trying to push a struct to list, thing is I have to do this without the use of standard libraries (so no malloc, or calloc etc). Therefore I am struggling a bit, this is what I've got so far.
typedef struct node node_t;
struct node{
int val;
node_t *next;
node_t *prev;
};
node_t nodes[10];
node_t blocked[10];
void init(){
for(int i = 0; i < 10; i++){
nodes[i].val = i;
if(i == 0){
nodes[i].next = &nodes[i+1];
nodes[i].prev = NULL;
}
else if(i == 9){
nodes[i].next = NULL;
nodes[i].prev = &nodes[i-1];
}else{
nodes[i].next = &nodes[i+1];
nodes[i].prev = &nodes[i-1];
}
}
}
node_t *push(node_t **arr, node_t node){
node_t *newhead = &node;
printf("%d\n", newhead->val);
newhead->next = (*arr);
printf("%d\n", (*arr)->val);
return newhead;
}
int main(){
init();
node_t *head = &nodes[0];
node_t *blockhead = &blocked[0];
blockhead = push(&blockhead,nodes[3]);
blockhead = push(&blockhead,nodes[4]);
return 0;
}
The problem I have is that the list only keeps track of the last element I've added to the list, and will crash if trying to access the next value in the list which probably means I am trying to access a NULL pointer but everything seems correct as far as I can tell, but maybe I am missing something super obvious? The point of the "push" function as a whole is to simply add the node to the front of the list ahead of everything else.

Answer 1

Your immediate problem is there is no declaration for node prior to:
node_t *newhead = &node;
You are taking the address of something that doesn't exist -- that's never a good idea (and invokes Undefined Behavior and generally a SegFault).
There is no need for nodes to be declared globally and no need for blocked at all (based on your current code). Avoid using global variables. Declare your variables in main() and pass the variables (or a pointer) to any functions as required.
If you are using an array of type node_t as a linked list without allocation, and are then looking to "push" (e.g. add a new node_t at the beginning as the new list address) then you are essentially just needing to have you newnode.next point to your nodes array (as the address of an array is simply a pointer to its first member) and you need array[0].prev to point to the address of newnode.
From what I can glean from your question, the purpose for the code is an exercise in pointer understanding. Regardless of whether you are dealing with a list stored on the stack or one allocated globally, if you change the first-node in the list, you are changing the list address (because the start of the list is the address of the first node) In order to change the list address within a function, you must pass the address of the list as a parameter to the function --or-- you return a pointer to the new first node and assign address to your list pointer back in the caller. (both are shown below)
Since you are wanting to "push" a locally declared node to the head of the list, in like manner, you must pass the address of that node to your push function so it is working with the actual address of that node rather than the address of the copy of the node created if the node itself is passed as a parameter to your push function. You can do this with something similar to the following to handle addressing your array of nodes as a list through a new node pushed to the head of the list:
/* push takes address of array and address of node as parameters */
node_t *push (node_t **arr, node_t *node)
{
node->next = *arr; /* next for new node is list address */
(*arr)[0].prev = node; /* prev for list is new node address */
*arr = node; /* new node address is new list address */
return node; /* return pointer to new 1st node */
}
Above you are simply setting newnode->next to the current list address, then setting the list->prev to point to the new node, and then setting the list address as the address of the newnode (a pointer to that address is also returned which can be assigned back in the caller, as needed).
The remainder of the changes were really just clean-ups to what you had, adding parameters to your functions as required so that nodes can be properly declared in main() and adding a prn function to print the list. Also node there are no magic numbers used in the code. If you need a constant #define one (or more), or use a global enum to define them (that is a valid use of a global).
Putting it altogether, you could do something like the following:
#include <stdio.h>
#define LMAX 10 /* if you need a constant, define one */
typedef struct node {
int val;
struct node *prev, *next;
} node_t;
void init (node_t *nodes)
{
for (int i = 0; i < LMAX; i++){
nodes[i].val = i;
if (i == 0)
nodes[i].prev = NULL;
else {
nodes[i-1].next = &nodes[i];
nodes[i].prev = &nodes[i-1];
}
}
}
/* push takes address of array and address of node as parameters */
node_t *push (node_t **arr, node_t *node)
{
node->next = *arr; /* next for new node is list address */
(*arr)[0].prev = node; /* prev for list is new node address */
*arr = node; /* new node address is new list address */
return node; /* return pointer to new 1st node */
}
/* simple print list */
void prn (node_t *list)
{
for (; list; list = list->next)
printf (" %d", list->val);
putchar ('\n');
}
int main (void) {
node_t nodes[LMAX], /* array of nodes */
*head = nodes, /* list pointer */
singlenode = { .val = LMAX }; /* new node to push */
init(head); /* init list */
prn (head); /* print list */
push (&head, &singlenode); /* push new node to list */
prn (head); /* print new list */
return 0;
}
Example Use/Output
$ ./bin/lldblstatic
0 1 2 3 4 5 6 7 8 9
10 0 1 2 3 4 5 6 7 8 9
Look things over, paying attention to the use of addresses and pointers. If you have further questions, do not hesitate to ask.