allocation of local variable inside a method/function - c

Question

I was making a dynamic linked list in C, something similar to what we have in Java.
I was wrapping the element/value inside a struct which has the value and the address of the next node. I didn't feel like passing an instance of the struct itself, so I made a method that accepts the value and adds that value in the struct((you can say this struct is abstracted out, someone using the method won't know that there a struct being used inside the method) and then adds that struct to the list.
To test the code, I added 5 different integers and that struct I made inside the method got the same memory address during all the 5 additions.
This code was compiled using gcc and was written and tested in ubuntu.
struct node {
void* value; // literal values can't be passed in here, only address can be passed
struct node* next; // poninter to the next node
};
typedef struct {
size_t size; // size of the linked list
struct node* head; // head node of the list, always points to the first element in the list
} link_list;
void link_list_add(link_list * list, struct node * ele) {
// if size is zero, simply add the node to the list
if(list->size==0) {
list->head = ele;
ele->next = NULL;
}
else {
// add the new node to the front of the list and make in point towards what is being pointed by the list head
ele->next = list->head;
list->head = ele;
}
list->size++;
}
// does the same thing as the previous method, the only difference being that it takes the address of the element that needs to add and makes the wrapper node struct for it.
void link_list_add_ele(link_list * list, void * ele){
struct node eleNode = {ele, NULL}; // this gives the same address every single time.
link_list_add(list, eleNode);
}

Answer 1

This defines a local variable:
struct node eleNode = {ele, NULL}; // this gives the same address every single time.
It is allocated when the link_list_add_ele function is called and freed when the function returns. The next time you call the function, its memory might be reused.
What you're looking for is a dynamic memory allocation (like new in Java):
void link_list_add_ele(link_list * list, void * ele){
struct node *eleNode = malloc(sizeof(struct node));
eleNode->value = ele;
eleNode->next = 0;
link_list_add(list, eleNode);
}
But remember that such memory would also need to be explicitly freed by a call to free(), as C doesn't have a garbage collector.

Answer 2

Stack memory like struct node eleNode = {ele, NULL}; is no longer valid once the function returns. After the function returns the memory will be reused.
Anything simpler than basic type like a float, integer, or pointer that you want to return you need to use malloc to allocate heap memory. That memory will remain allocated until it is freed or the program exits.
It's a good idea to put your struct allocation and freeing into a function for DRY purposes and to isolate it from the rest of the code. While it's simple now, struct allocation is often complicated.
struct node *node_new {
return malloc(sizeof(struct node));
}
void link_list_add_ele(link_list * list, void * ele){
struct node *eleNode = node_new();
eleNode->value = ele;
eleNode->next = NULL;
link_list_add(list, eleNode);
}
And when you delete a node you must free the memory.
void node_free(struct node *node) {
free(node);
}

Answer 3

What you have been observing is right. The Linked List nodes should be allocated dynamically (i.e, using functions like malloc, calloc or realloc) if you want to use the Linked List beyond the scope of the function in which you have created it. You need to free the dynamically allocated memory once they are not needed. If you don't do that, then you will have memory leaks.
To test the code, I added 5 different integers and that struct I made inside the method got the same memory address during all the 5 additions.
It is because you have been allocating the node over Stack memory and hence, it has automatic storage class (Learn more about Storage Classes). The memory location allocated to that node will destroyed when you exit from your function link_list_add_ele. It is no longer valid once the wrapper function returns.
One more point:
You have been passing wrong parameters to link_list_add. The second parameter is a pointer but you have been passing it a value.
One important remark:
Try to understand various Warnings and Errors thrown by your compiler.
In my Linux, I try to compile my code with various verbose warning flags.
gcc example.c -o example -Wall -Wextra -Wshadow
If you are using an IDE, then there will be some settings options to enable warning.
I compiled your code with gcc filename.c -Wall and it gave me this error:
error: incompatible type for argument 2 of ‘link_list_add’
link_list_add(list, eleNode);
^~~~~~~
note: expected ‘struct node *’ but argument is of type ‘struct node’
void link_list_add(link_list * list, struct node * ele) {
I have edited your function to remove the Warnings and allocated the memory over heap:
#include <stdio.h>
#include <stdlib.h>
void link_list_add_ele(link_list *list, void *ele)
{
struct node *eleNode = malloc(sizeof(struct node)); // this gives the same address every single time.
eleNode->value = ele;
eleNode->next = NULL;
link_list_add(list, eleNode);
}
You also need to include the header file #include <stdlib.h> and don't forget to free the memory once it is not needed as C doesn't have automatic garbage collection and hence, you may observe memory leaks if you don't free them properly.