Dynamic buffer in C: solved exercise

If you searched for a solved dynamic buffer in C, here is the classic dynamic array pattern: initial malloc, realloc when capacity is exhausted, and free at the end. The doubling strategy guarantees that the amortized insertion cost is O(1).

This pattern is the foundation of structures like std::vector in C++ or ArrayList in Java, implemented manually in C.

Problem statement

Implement a dynamic integer array with:

buf_create(initial_cap): creates the buffer.
buf_append(b, val): adds an element, doubling capacity if needed.
buf_print(b): displays all elements.
buf_free(b): releases the memory.

Add the integers from 1 to 10 starting with an initial capacity of 2 to force several realloc calls.

C solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int  *data;
    int   size;
    int   capacity;
} Buffer;

Buffer *buf_create(int initial_cap) {
    Buffer *b = malloc(sizeof(Buffer));
    if (!b) return NULL;
    b->data     = malloc(initial_cap * sizeof(int));
    if (!b->data) { free(b); return NULL; }
    b->size     = 0;
    b->capacity = initial_cap;
    return b;
}

int buf_append(Buffer *b, int val) {
    if (b->size == b->capacity) {
        int new_cap = b->capacity * 2;
        int *tmp = realloc(b->data, new_cap * sizeof(int));
        if (!tmp) return -1;           /* b->data unchanged on failure */
        b->data     = tmp;
        b->capacity = new_cap;
        printf("  [realloc] capacity -> %d\n", new_cap);
    }
    b->data[b->size++] = val;
    return 0;
}

void buf_print(const Buffer *b) {
    printf("Buffer [%d/%d]: ", b->size, b->capacity);
    for (int i = 0; i < b->size; i++) printf("%d ", b->data[i]);
    printf("\n");
}

void buf_free(Buffer *b) {
    if (!b) return;
    free(b->data);
    free(b);
}

int main(void) {
    Buffer *b = buf_create(2);
    if (!b) { perror("buf_create"); return 1; }

    for (int i = 1; i <= 10; i++) {
        if (buf_append(b, i) != 0) {
            fprintf(stderr, "Error appending %d\n", i);
            buf_free(b);
            return 1;
        }
    }

    buf_print(b);
    buf_free(b);
    return 0;
}

Expected output

1
2
3
4
  [realloc] capacity -> 4
  [realloc] capacity -> 8
  [realloc] capacity -> 16
Buffer [10/16]: 1 2 3 4 5 6 7 8 9 10 

Common mistakes

Assigning the result of realloc directly to b->data: if realloc returns NULL, the original pointer is lost and cannot be freed, causing a memory leak. Always use a temporary variable tmp.
Not freeing b->data before freeing b: free(b) only frees the container struct, not the internal array.
Not checking the return value of malloc or realloc: dereferencing a NULL pointer is undefined behavior.
Using a growth factor of 1 (adding only one slot of capacity): leads to O(n²) total insertion time because every insertion triggers a realloc.

Practical use

The dynamic array is the most widely used data structure in practice: reading lines of variable length, storing query results whose size is not known in advance, implementing variable-size stacks and queues, and as the basic building block of parsers and compilers.

Recommended next exercise

Guided practice and full book

If you want a complete path with progressive difficulty:

FAQ

Why double the capacity instead of increasing it by a fixed amount?

With a fixed increment of k, inserting n elements requires n/k calls to realloc, each copying all previous elements. The total cost is O(n²/k) = O(n²). With doubling, only log₂(n) calls are needed and the amortized cost per insertion is O(1), with total cost O(n).

What happens if `realloc` cannot find contiguous memory?

realloc may move the block to a different memory region: it copies the data, frees the original block, and returns the new pointer. If no memory is available, it returns NULL and the original block remains intact. That is why a temporary variable must be used before reassigning.

When should `calloc` be used instead of `malloc` for the buffer?

Use calloc if you need to guarantee that elements are initialized to zero (for example, to detect unwritten values or for compatibility with code that assumes zeros). For an array where all elements will be written before being read, malloc is sufficient and slightly faster.

Dynamic buffer in C: solved exercise