How to store custom objects (struct) in C?

I want to know how to store custom objects (not their pointers) in C. I have created a custom structure called Node

#define MAXQ 100

typedef struct {
  int state[MAXQ];
  int height;
} Node;

(which works) and I want to store a few of these Nodes in a container (without using pointers, since they are not stored elsewhere) so I can access them later.

The internet seems to suggest something like calloc() so my last attempt was to make a container Neighbors following this example, with numNeighbors being just an integer:

Node Neighbors = (Node*)calloc(numNeighbors, sizeof(Node));

At compilation, I got an error from this line saying
initializing 'Node' with an expression of incompatible type 'void *'

and in places where I referenced to this container (as in Neighbors[i]) I got errors of
subscripted value is not an array, pointer, or vector

Since I'm spoiled by Python, I have no idea if I've got my syntax all wrong (it should tell you something that I'm still not there after scouring a ton of tutorials, docs, and stackoverflows on malloc(), calloc() and the like), or if I am on a completely wrong approach to storing custom objects (searching "store custom objects in C" on the internet gives irrelevant results dealing with iOS and C# so I would really appreciate some help).

EDIT: Thanks for the tips everyone, it finally compiled without errors!

Solution

I want to store a few of these Nodes in a container (without using pointers, since they are not stored elsewhere) so I can access them later.

If you know the amount of them at compile-time (or at the very least a reasonable maximum); then you can create an array of stack-allocated objects. For instance, say you are OK with a maximum of 10 objects:

#define MAX_NODES 10

Node nodes[MAX_NODES];
int number_nodes = 0;

Then when you add an object, you keep in sync number_nodes (so that you know where to put the next one). Technically, you will always have 10, but you only use the ones you want/need. Removing objects is similar, although more involved if you want to take out some in the middle.

However, if you don't know how many you will have (nor a maximum); or even if you know but they are way too many to fit in the stack; then you are forced to use the heap (typically with malloc() and free()):

int number_nodes; // unknown until runtime or too big
Node * nodes = malloc(sizeof(Node) * number_nodes);
...
free(nodes);

In any case, you will be using pointers in the dynamically allocated memory case, and most probably in the stack case as well.

Python is hiding and doing all this dance for you behind the scenes -- which is quite useful and time saving as you have probably already realized, as long as you do not need precise control over it (read: performance).