Question

I’m just reading about malloc() in C.

The Wikipedia article provides an example, however it justs allocate enough memory for an array of 10 ints in comparison with int array[10]. Not very useful.

When would you decided to use malloc() over C handling the memory for you?

Answer 1

Dynamic data structures (lists, trees, etc.) use malloc to allocate their nodes on the heap. For example:

/* A singly-linked list node, holding data and pointer to next node */
struct slnode_t
{
    struct slnode_t* next;
    int data;
};

typedef struct slnode_t slnode;

/* Allocate a new node with the given data and next pointer */
slnode* sl_new_node(int data, slnode* next)
{
    slnode* node = malloc(sizeof *node);
    node->data = data;
    node->next = next;
    return node;
}

/* Insert the given data at the front of the list specified by a 
** pointer to the head node
*/
void sl_insert_front(slnode** head, int data)
{
    slnode* node = sl_new_node(data, *head);
    *head = node;
}

Consider how new data is added to the list with sl_insert_front. You need to create a node that will hold the data and the pointer to the next node in the list. Where are you going to create it?

• Maybe on the stack! – NO – where will that stack space be allocated? In which function? What happens to it when the function exits?
• Maybe in static memory! – NO – you’ll then have to know in advance how many list nodes you have because static memory is pre-allocated when the program loads.
• On the heap? YES – because there you have all the required flexibility.

malloc is used in C to allocate stuff on the heap – memory space that can grow and shrink dynamically at runtime, and the ownership of which is completely under the programmer’s control. There are many more examples where this is useful, but the one I’m showing here is a representative one. Eventually, in complex C programs you’ll find that most of the program’s data is on the heap, accessible through pointers. A correct program always knows which pointer “owns” the data and will carefully clean-up the allocated memory when it’s no longer needed.