Dynamic Array Implementation with `malloc()` and `realloc()`

What is a Dynamic Array?

A standard C array has a fixed size determined at compile time. A dynamic array, in contrast, is an array that can grow or shrink at runtime. To implement this, we need to manage a block of memory on the heap and keep track of two key properties:

• Logical Size (or size): The number of elements currently stored in the array.
• Capacity: The total number of elements the currently allocated memory block can hold.

The core idea is that we often allocate more memory than we immediately need. When the logical size reaches the capacity, we allocate a new, larger block of memory, copy the old data over, and then free the old block. This process is efficiently handled by realloc().

Let's begin by reading a short article that visualizes this concept.

Designing the Dynamic Array Structure

To manage our dynamic array, we need to bundle the data pointer, the logical size, and the capacity together. A struct is the perfect tool for this. A well-designed dynamic array should also be generic, meaning it can hold any data type. We can achieve this by storing the size of each item.

Here is a common and robust design for a dynamic array structure in C:

typedef struct {
    void *data;          // Pointer to the block of memory on the heap
    size_t itemSize;     // The size of a single item (e.g., sizeof(int))
    size_t size;         // The current number of items (logical size)
    size_t capacity;     // How many items the allocated memory can hold
} DynamicArray;

With this structure, we can create a set of functions to initialize the array, add elements, and clean it up.

The Core Logic: Appending and Resizing

The most critical operation is appending a new element. This is where the "dynamic" nature comes into play. The logic is as follows:

1. Check if the array is full (array->size == array->capacity).
2. If it is full, calculate a new, larger capacity. A common strategy is to double the current capacity.
3. Use realloc() to resize the memory block pointed to by data.
4. Once there is enough capacity, copy the new element to the end of the array.
5. Increment the size.

The following short video demonstrates this core resizing logic in a very direct, code-focused way.

A Safer realloc Pattern

One crucial detail when using realloc() is handling potential allocation failures. realloc() returns NULL if it cannot resize the memory. If you assign this NULL back to your original pointer, you lose your only reference to the old memory block, creating a memory leak.

Unsafe Pattern:

// If realloc fails, arr becomes NULL and the original memory is leaked.
arr = realloc(arr, new_size); 

Safe Pattern:

// Use a temporary pointer.
int *temp = realloc(arr, new_size);
if (temp == NULL) {
    // Handle the error: maybe free the original memory and exit.
    free(arr);
    // ... handle failure ...
} else {
    // Only update the pointer on success.
    arr = temp;
}

This safe pattern is essential for writing robust code, a principle you're very familiar with from your work in functionally safe systems.

The internal mechanism of realloc is also interesting. If it can expand the memory block in-place, it will. If not, it finds a new, larger block, copies the data from the old block to the new one, and frees the old block for you.

A Complete, Generic Implementation

Now, let's put it all together. The Brilliant.org article we looked at earlier provides a full, clean, and generic implementation of a dynamic array. It uses void* and memcpy to handle items of any size, which is a common and powerful pattern in C.

Dynamic Arrays of Structs and Nested Allocations

The generic implementation is powerful, but it's also helpful to see a concrete example with a more complex data type, like a struct. Your work in automotive systems often involves managing complex data structures for CAN frames, service-oriented communication, or ADAS sensor data.

The following video demonstrates creating a dynamic array of structs and brings up a critically important point about cleanup.

The final point in the video is paramount. If your data structure contains pointers to other dynamically allocated memory, you are responsible for freeing that "inner" memory before freeing the "outer" container. A single free(array) call is not enough. This principle of ownership and cleanup is fundamental to managing complex resources in C.

void DynamicArrayShrinkToFit(DynamicArray *dynamicArray);

void DynamicArrayShrinkToFit(DynamicArray *dynamicArray) {
    // 1. Only act if capacity is greater than size.
    if (dynamicArray->capacity > dynamicArray->size) {
        
        // Handle the edge case of shrinking to zero.
        if (dynamicArray->size == 0) {
            free(dynamicArray->internalArray);
            dynamicArray->internalArray = NULL; // Good practice!
        } else {
            // 2. Use realloc with the safe pattern.
            void *temp = realloc(dynamicArray->internalArray, dynamicArray->size * dynamicArray->itemSize);
            
            // 3. Check for realloc failure. In this case, we can just keep the old, larger buffer.
            if (temp != NULL) {
                dynamicArray->internalArray = temp;
            }
            // If realloc fails, we simply fail to shrink, which is acceptable.
        }

        // 4. Update the capacity to match the new size.
        dynamicArray->capacity = dynamicArray->size;
    }
}

Conclusion

In this lesson, you've built a complete, non-trivial data structure in C from first principles. This is a significant step in mastering pointers and memory management. You have moved beyond simply using allocation functions to designing a system that encapsulates memory logic, which is the foundation of creating robust and scalable C programs.

Key Takeaways:

• A dynamic array is implemented using a pointer to heap memory, along with size and capacity counters managed in a struct.
• The append operation's core logic involves checking if size == capacity, and if so, using realloc to expand the memory buffer.
• Safe realloc usage involves a temporary pointer to prevent memory leaks if allocation fails.
• A generic dynamic array can be created using void* pointers, itemSize tracking, and memcpy for data manipulation.
• When managing arrays of complex structures, you must ensure that any nested dynamically allocated memory within those structures is freed before freeing the array itself.

Preview of the Next Lesson:
We've implemented a functional dynamic array, but we only briefly touched on the safe realloc pattern. For code to be truly production-ready, especially in the high-stakes environment of automotive software, error handling must be systematic and robust. In our next lesson, we will focus exclusively on how to handle memory allocation failures and write robust error-checking code, turning our prototype-level functions into hardened, reliable components.