Don't I have to malloc() this array? - c

Question

I'm struggling to learn the C rules of malloc() / free(). Consider the below code, which runs just fine. (On Linux, compiled with GCC.) Specifically, I'm wondering about the arr array. I get that you have to malloc for all the struct elements within the array... but why don't you have to malloc for the array itself?
#include<stdio.h>
#include<stdlib.h>
#define ARR_SIZE 100
typedef struct containerStruct{
int data1;
int data2;
int data3;
// ...etc...
} container;
int main(){
container* arr[ARR_SIZE]; // Don't I have to malloc this?
int i;
for(i=0; i<ARR_SIZE; i++){
arr[i] = (container*) malloc (sizeof(container)); // I get why I have to malloc() here
}
...do stuff...
for(i=0; i<ARR_SIZE; i++){
free(arr[i]); // I get why I have to free() here
}
// Don't I have to free(arr) ?
return 0;
}
I'm guessing that the container* arr[ARR_SIZE]; line tells the compiler all it needs to know to carve out the space in memory for the array, which is why this code works.
But it still doesn't "feel" right, somehow. When I malloc() something, I'm reserving memory space on the heap, right? But my container* arr[ARR_SIZE]; call creates the array on the stack. So... the array of container* porters exists on the stack, and all of those container* pointers point to a container struct on the heap. Is that correct?

Answer 1

Right beneath your declaration of arr, you have the following:
int i;
Which reserves enough space (probably on the "stack") to store an int. Does this "feel" wrong to you as well?
The declaration of arr is no different. The compiler allocates enough space (probably on the "stack") for a ARR_SIZE element array of container *s.

Answer 2

When I malloc() something, I'm reserving memory space on the heap, right?
Don't say that, the heap is an implementation detail. You're dynamically allocating memory. You're also responsible for dynamically freeing it again.
But my container* arr[ARR_SIZE]; call
It's not a call, it's a declaration.
creates the array on the stack.
Don't say that either, the stack is also an implementation detail.
You're declaring a local (here an array of pointers) with automatic scope, and the compiler is responsible for managing its memory and lifetime.
Its lifetime isn't dynamic, because it becomes unreachable as soon as you reach the } at the end of the enclosing block, and so the compiler can handle it for you deterministically.
All local variables behave the same here:
{
int i;
double d[2];
} /* neither i nor d are reachable after here,
so the compiler takes care of releasing any storage */
So... the array of container* pointers exists on the stack,
Consider the simpler declaration container c;. This is a local with automatic scope, and the compiler takes care of (de)allocation as discussed.
Now consider container *p;. This is also a local variable with automatic scope, but the variable is a pointer. You still need to point it at something manually, and if the thing you point it at was returned from malloc, you'll need to free it yourself.
Further consider a simple array container a[2];. Now you have a local array with automatic scope, containing two instances of your container type. Both instances have the same lifetime, it's still managed by the compiler. You can access a[0] and a[1] and pretty much anything else is illegal.
and all of those container* pointers point to a container struct on the heap. Is that correct?
No. Finally consider container* ap[2]. Again we have a local array with automatic scope, containing two pointers. The type of the pointer is pointer-to-container, and the lifetime of the pointers is managed by the compiler. However, the pointers don't point at anything yet, and it'll be your responsibility to decide what to point them at, and figure out what lifetime that pointed-at thing has.
Once you do
ap[i] = malloc(sizeof(*ap[i]));
(you don't need to cast, and it's generally safer to avoid naming the type explicitly, in case you change it later and allocate the wrong size), you've allocated an object which you're responsible for freeing. You've also pointed one of the pointers in your array at this object, but that doesn't somehow change the lifetime of the pointer itself. The array just goes out of scope like usual wherever its pointers point.

Answer 3

You can choose either one of the following options:
int i;
container** arr = malloc(sizeof(container*)*ARR_SIZE);
for (i=0; i<ARR_SIZE; i++)
arr[i] = malloc(sizeof(container));
// do stuff...
for(i=0; i<ARR_SIZE; i++)
free(arr[i]);
free(arr);
int i;
container* arr[ARR_SIZE];
for (i=0; i<ARR_SIZE; i++)
arr[i] = malloc(sizeof(container));
// do stuff...
for(i=0; i<ARR_SIZE; i++)
free(arr[i]);
container arr[ARR_SIZE];
// do stuff...
Since ARR_SIZE is constant, you may as well choose the last option.

Answer 4

Since ARR_SIZE is fixed member of the dynamic array *arr[ARR_SIZE], you no longer have to allocate memory for the whole array, but just the elements within it, as they are flexible in this case.
When you malloc any sort of dynamic array, it is safe to always check the return value of the void* pointer returned from malloc. Additionally, when you free each element, it is even safer to set each member to NULL again, to prevent the pointer from accessing memory again.
Illustrated through this code:
#include <stdio.h>
#include <stdlib.h>
#define ARR_SIZE 100
typedef struct {
int data1;
int data2;
int data3;
// ...etc...
} container_t;
int
main(void) {
container_t *arr[ARR_SIZE];
int i;
for (i = 0; i < ARR_SIZE; i++) {
arr[i] = malloc(sizeof(container_t));
if (arr[i] == NULL) {
printf("Malloc Problem here\n");
exit(EXIT_FAILURE);
}
}
for (i = 0; i < ARR_SIZE; i++) {
if (arr[i]) {
free(arr[i]);
arr[i] = NULL;
}
}
return 0;
}

Answer 5

container* arr[ARR_SIZE]; tells the compiler to allocate an array of ARR_SIZE elements of type container* and compiler allocates the memory accordingly.
In other words, this is similar to saying int x[5] = 0; where compiler allocates enough space for an array of 5 ints. In your case, compiler allocates enough space for ARR_SIZE number of pointers, container* and that is it. Now, it's upto you to make those pointers point to valid memory location. For that, you can either
use memory allocator functions (which allocates memory from heap, as you mentioned)
assign the address of other variables of the same type (does not need allocation from heap, anyway).
So, the bottom line, you don't need to allocate any memory for the array. For each individual array elements, you need to allocate memory using memory allocator functions as you want each elements to point to valid memory.