pointer confusion with malloc - c

Question

I have a working implementation of my code with a ton of mallocs. It has
struct* node myList;
struct node { ... } // contains stuff
struct* node_constructor(...) {
node* tempnode = (node*) malloc(sizeof(node));
node* next = ...;
... // some other info
}
and then in my main function I call
myList = node_constructor(myList,otherarguments...);
I'm thinking there's probably a way to do something like
temp = (node*) malloc(sizeof(node)*numberOfNodes);
for(i=0; i<numberOfNodes;i++) { temp[i].next = temp[i-1]; ... } // wrong?
temp[numberOfNodes-1]; // set myList equal to the last one
and get rid constructor function and all those individual mallocs, I just seem to be getting confused with what to do with my malloced space. So temp is a (node*), so I'm pretty sure my temp[i].next = temp[i-1] thing is wrong...and maybe some of the other ideas are too. If anyone has any advice/input, I'd appreciate it.

Answer 1

Ok, Sure, you could do that, kinda. As long as temp is big enough and you know that size beforehand. And temp would more likely be a void* or some generic container just to hang onto unspecified memory rather than node. (Because it's not a node, it's where all your nodes go. temp[x] when temp is malloced is kind of a hack).
But now you want to add another node to your list. How do you do that?
The individual mallocs let you add a single item to the list. And if you are in a situation where you want to add a number of items to your list, then you can just call the individual functions multiple times.
The idea of allocating a large pool of memory, and divvying it up into the piecemeal sections later is a valid idea and it has some performance benefits, but it's of limited niche use.
Allocating just enough memory for one more item is a lot more handy and common. You're not wrong, but trust me, learn how to do it the normal way first.

Answer 2

If you are going to back your list with an array there is no need to have next pointers - the next object is the next index in the array.
There are both advantages and disadvantages with an array list implementation compared to a linked list implementation.

Answer 3

Ideally, you would have a node like this:
typedef struct node
{
struct node* next;
struct node* prev; // optional for double-linked list
uint8_t* data;
size_t data_size;
} node_t;
and then create it as
result_t list_add (const void* data, size_t size)
{
if(list_is_full()) // if applicable
{
return list_is_full_error;
}
node_t* new_node = node_constructor(data, size);
if(new_node == NULL)
{
return memory_error;
}
list_add(new_node);
return ok;
}
static node_t* node_constructor (const void* data, size_t size)
{
node_t* new_node = malloc(*new_node);
if(new_node == NULL)
{
return NULL;
}
new_node->data = malloc(size);
if(new_node->data == NULL)
{
return NULL;
}
new_node->size = size;
memcpy(new_node->data, data, size);
return new_node;
}
static void list_insert (node_t* new_node)
{
// add the node to the linked list here
// set next/prev pointers of the new node and of adjacent nodes
// increase node counter (linked list size) if applicable
}