In C, arrays have a fixed size determined at compile time. But real-world applications rarely have such predictable data needs. Dynamic array resizing is the art of creating flexible data structures that can grow (and sometimes shrink) as your program runs. This fundamental technique underlies many higher-level language features like Python lists, Java ArrayList, and C++ vectors. Understanding how to implement dynamic arrays in C gives you insight into how these abstractions work and provides essential skills for systems programming.

What is a Dynamic Array?

A dynamic array is a data structure that:

1. Allocates memory on the heap (not the stack)
2. Tracks its capacity (total allocated space)
3. Tracks its size (currently used elements)
4. Grows automatically when more space is needed

Basic Structure:

typedef struct {
int *data;      // Pointer to array elements
size_t size;    // Number of elements currently stored
size_t capacity; // Maximum elements before resizing needed
} DynamicArray;

The Foundation: malloc, calloc, and realloc

Before implementing dynamic arrays, we need to understand the memory allocation functions.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void demonstrate_allocation_functions() {
// malloc - allocates uninitialized memory
int *arr1 = malloc(5 * sizeof(int));
printf("malloc: arr1[0] = %d (garbage)\n", arr1[0]);
// calloc - allocates and zero-initializes
int *arr2 = calloc(5, sizeof(int));
printf("calloc: arr2[0] = %d (zero)\n", arr2[0]);
// realloc - resizes existing allocation
int *arr3 = malloc(3 * sizeof(int));
arr3[0] = 10; arr3[1] = 20; arr3[2] = 30;
// Resize to 5 elements
int *arr3_resized = realloc(arr3, 5 * sizeof(int));
if (arr3_resized) {
arr3 = arr3_resized;
arr3[3] = 40; arr3[4] = 50;
printf("realloc: now has %d elements\n", 5);
}
// Clean up
free(arr1);
free(arr2);
free(arr3);
}

Simple Dynamic Array Implementation

1. Basic Dynamic Array Structure

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int *data;
size_t size;
size_t capacity;
} IntArray;
// Create a new dynamic array
IntArray* int_array_create() {
IntArray *arr = malloc(sizeof(IntArray));
if (!arr) return NULL;
arr->data = NULL;
arr->size = 0;
arr->capacity = 0;
return arr;
}
// Free the array and its data
void int_array_free(IntArray *arr) {
if (arr) {
free(arr->data);
free(arr);
}
}
// Get element at index (with bounds checking)
int int_array_get(IntArray *arr, size_t index) {
assert(arr && index < arr->size);
return arr->data[index];
}
// Set element at index
void int_array_set(IntArray *arr, size_t index, int value) {
assert(arr && index < arr->size);
arr->data[index] = value;
}
// Print array
void int_array_print(IntArray *arr) {
printf("Array (size=%zu, capacity=%zu): [", arr->size, arr->capacity);
for (size_t i = 0; i < arr->size; i++) {
printf("%d", arr->data[i]);
if (i < arr->size - 1) printf(", ");
}
printf("]\n");
}
int main() {
IntArray *arr = int_array_create();
// Initially empty
int_array_print(arr);
int_array_free(arr);
return 0;
}

2. Adding Elements with Resizing

// Resize the array to new capacity
int int_array_resize(IntArray *arr, size_t new_capacity) {
if (!arr) return -1;
// Allocate new memory
int *new_data = realloc(arr->data, new_capacity * sizeof(int));
if (!new_data && new_capacity > 0) {
return -1;  // Allocation failed
}
arr->data = new_data;
arr->capacity = new_capacity;
// If shrinking, adjust size
if (arr->size > new_capacity) {
arr->size = new_capacity;
}
return 0;
}
// Append an element to the end
int int_array_append(IntArray *arr, int value) {
if (!arr) return -1;
// Check if we need to grow
if (arr->size >= arr->capacity) {
size_t new_capacity = arr->capacity == 0 ? 4 : arr->capacity * 2;
if (int_array_resize(arr, new_capacity) != 0) {
return -1;  // Resize failed
}
}
arr->data[arr->size++] = value;
return 0;
}
int main() {
IntArray *arr = int_array_create();
printf("Appending elements:\n");
for (int i = 1; i <= 10; i++) {
int_array_append(arr, i * 10);
printf("After appending %d: ", i * 10);
int_array_print(arr);
}
int_array_free(arr);
return 0;
}

3. Inserting and Deleting Elements

// Insert at specific position
int int_array_insert(IntArray *arr, size_t index, int value) {
if (!arr || index > arr->size) return -1;
// Ensure space
if (arr->size >= arr->capacity) {
size_t new_capacity = arr->capacity == 0 ? 4 : arr->capacity * 2;
if (int_array_resize(arr, new_capacity) != 0) {
return -1;
}
}
// Shift elements right
for (size_t i = arr->size; i > index; i--) {
arr->data[i] = arr->data[i - 1];
}
arr->data[index] = value;
arr->size++;
return 0;
}
// Remove element at index
int int_array_remove(IntArray *arr, size_t index) {
if (!arr || index >= arr->size) return -1;
// Shift elements left
for (size_t i = index; i < arr->size - 1; i++) {
arr->data[i] = arr->data[i + 1];
}
arr->size--;
// Optional: shrink if too empty
if (arr->size > 0 && arr->size <= arr->capacity / 4) {
size_t new_capacity = arr->capacity / 2;
int_array_resize(arr, new_capacity);
}
return 0;
}
int main() {
IntArray *arr = int_array_create();
// Add some elements
for (int i = 0; i < 5; i++) {
int_array_append(arr, i * 10);
}
printf("Original: ");
int_array_print(arr);
// Insert at position 2
int_array_insert(arr, 2, 99);
printf("After inserting 99 at index 2: ");
int_array_print(arr);
// Remove at position 3
int_array_remove(arr, 3);
printf("After removing index 3: ");
int_array_print(arr);
int_array_free(arr);
return 0;
}

4. Growth Strategies

Different applications benefit from different growth strategies.

#include <stdio.h>
#include <stdlib.h>
typedef enum {
GROWTH_FIXED,      // Add fixed amount each time
GROWTH_DOUBLE,     // Double capacity (most common)
GROWTH_FIBONACCI,  // Fibonacci sequence growth
GROWTH_GOLDEN      // Golden ratio (φ ≈ 1.618)
} GrowthStrategy;
typedef struct {
int *data;
size_t size;
size_t capacity;
GrowthStrategy strategy;
size_t growth_factor;
} FlexibleArray;
// Initialize with specific strategy
FlexibleArray* flex_array_create(GrowthStrategy strategy, size_t initial_cap) {
FlexibleArray *arr = malloc(sizeof(FlexibleArray));
if (!arr) return NULL;
arr->data = malloc(initial_cap * sizeof(int));
if (!arr->data && initial_cap > 0) {
free(arr);
return NULL;
}
arr->size = 0;
arr->capacity = initial_cap;
arr->strategy = strategy;
arr->growth_factor = 2;  // Default for doubling
return arr;
}
// Calculate next capacity based on strategy
size_t next_capacity(FlexibleArray *arr) {
switch (arr->strategy) {
case GROWTH_FIXED:
return arr->capacity + 10;  // Add 10 each time
case GROWTH_DOUBLE:
return arr->capacity == 0 ? 4 : arr->capacity * 2;
case GROWTH_FIBONACCI: {
// Simple Fibonacci: 1, 2, 3, 5, 8, 13, 21...
static size_t fib_prev = 1, fib_curr = 2;
size_t next = fib_prev + fib_curr;
fib_prev = fib_curr;
fib_curr = next;
return next;
}
case GROWTH_GOLDEN: {
// Golden ratio ~1.618
double phi = 1.618033988749895;
size_t new_cap = (size_t)(arr->capacity * phi);
return new_cap > arr->capacity ? new_cap : arr->capacity + 1;
}
default:
return arr->capacity * 2;
}
}
// Append with strategy-based growth
int flex_array_append(FlexibleArray *arr, int value) {
if (!arr) return -1;
if (arr->size >= arr->capacity) {
size_t new_cap = next_capacity(arr);
int *new_data = realloc(arr->data, new_cap * sizeof(int));
if (!new_data) return -1;
arr->data = new_data;
arr->capacity = new_cap;
printf("  Grew from %zu to %zu (using ", 
arr->capacity, new_cap);
switch (arr->strategy) {
case GROWTH_FIXED: printf("fixed +10"); break;
case GROWTH_DOUBLE: printf("doubling"); break;
case GROWTH_FIBONACCI: printf("Fibonacci"); break;
case GROWTH_GOLDEN: printf("golden ratio"); break;
}
printf(")\n");
}
arr->data[arr->size++] = value;
return 0;
}
int main() {
GrowthStrategy strategies[] = {
GROWTH_FIXED, GROWTH_DOUBLE, GROWTH_FIBONACCI, GROWTH_GOLDEN
};
const char *names[] = {"Fixed +10", "Doubling", "Fibonacci", "Golden Ratio"};
for (int s = 0; s < 4; s++) {
printf("\n=== Growth Strategy: %s ===\n", names[s]);
FlexibleArray *arr = flex_array_create(strategies[s], 2);
for (int i = 1; i <= 20; i++) {
flex_array_append(arr, i);
if (i % 5 == 0) {
printf("  After %d elements: capacity = %zu\n", 
i, arr->capacity);
}
}
free(arr->data);
free(arr);
}
return 0;
}

Generic Dynamic Array Using void*

For true reusability, we can create a generic dynamic array that works with any data type.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
void *data;         // Pointer to elements
size_t size;        // Number of elements
size_t capacity;    // Maximum elements before resizing
size_t elem_size;   // Size of each element in bytes
} Vector;
// Create a new vector
Vector* vector_create(size_t elem_size) {
Vector *vec = malloc(sizeof(Vector));
if (!vec) return NULL;
vec->data = NULL;
vec->size = 0;
vec->capacity = 0;
vec->elem_size = elem_size;
return vec;
}
// Create with initial capacity
Vector* vector_create_with_capacity(size_t elem_size, size_t capacity) {
Vector *vec = vector_create(elem_size);
if (!vec) return NULL;
vec->data = malloc(capacity * elem_size);
if (!vec->data && capacity > 0) {
free(vec);
return NULL;
}
vec->capacity = capacity;
return vec;
}
// Free the vector
void vector_free(Vector *vec) {
if (vec) {
free(vec->data);
free(vec);
}
}
// Resize the vector
int vector_resize(Vector *vec, size_t new_capacity) {
if (!vec) return -1;
void *new_data = realloc(vec->data, new_capacity * vec->elem_size);
if (!new_data && new_capacity > 0) {
return -1;
}
vec->data = new_data;
vec->capacity = new_capacity;
if (vec->size > new_capacity) {
vec->size = new_capacity;
}
return 0;
}
// Ensure capacity for at least one more element
int vector_ensure_capacity(Vector *vec) {
if (!vec) return -1;
if (vec->size >= vec->capacity) {
size_t new_capacity = vec->capacity == 0 ? 4 : vec->capacity * 2;
return vector_resize(vec, new_capacity);
}
return 0;
}
// Push element (copy from src)
int vector_push(Vector *vec, const void *src) {
if (!vec || !src) return -1;
if (vector_ensure_capacity(vec) != 0) {
return -1;
}
// Copy element to the end
void *dest = (char*)vec->data + vec->size * vec->elem_size;
memcpy(dest, src, vec->elem_size);
vec->size++;
return 0;
}
// Get pointer to element at index
void* vector_get(Vector *vec, size_t index) {
if (!vec || index >= vec->size) return NULL;
return (char*)vec->data + index * vec->elem_size;
}
// Set element at index (copy from src)
int vector_set(Vector *vec, size_t index, const void *src) {
if (!vec || !src || index >= vec->size) return -1;
void *dest = (char*)vec->data + index * vec->elem_size;
memcpy(dest, src, vec->elem_size);
return 0;
}
// Pop last element
int vector_pop(Vector *vec, void *dest) {
if (!vec || vec->size == 0) return -1;
vec->size--;
if (dest) {
void *src = (char*)vec->data + vec->size * vec->elem_size;
memcpy(dest, src, vec->elem_size);
}
// Optional: shrink if too empty
if (vec->size > 0 && vec->size <= vec->capacity / 4) {
size_t new_capacity = vec->capacity / 2;
vector_resize(vec, new_capacity);
}
return 0;
}
// Insert at position
int vector_insert(Vector *vec, size_t index, const void *src) {
if (!vec || !src || index > vec->size) return -1;
if (vector_ensure_capacity(vec) != 0) {
return -1;
}
// Shift elements right
char *base = (char*)vec->data;
memmove(base + (index + 1) * vec->elem_size,
base + index * vec->elem_size,
(vec->size - index) * vec->elem_size);
// Insert new element
memcpy(base + index * vec->elem_size, src, vec->elem_size);
vec->size++;
return 0;
}
// Remove at position
int vector_remove(Vector *vec, size_t index, void *dest) {
if (!vec || index >= vec->size) return -1;
char *base = (char*)vec->data;
// Copy to dest if provided
if (dest) {
memcpy(dest, base + index * vec->elem_size, vec->elem_size);
}
// Shift elements left
memmove(base + index * vec->elem_size,
base + (index + 1) * vec->elem_size,
(vec->size - index - 1) * vec->elem_size);
vec->size--;
return 0;
}
// Clear all elements
void vector_clear(Vector *vec) {
if (vec) {
vec->size = 0;
}
}
// Print vector of ints (convenience function)
void print_int_vector(Vector *vec) {
printf("IntVector (size=%zu, cap=%zu): [", vec->size, vec->capacity);
for (size_t i = 0; i < vec->size; i++) {
int *val = (int*)vector_get(vec, i);
printf("%d", *val);
if (i < vec->size - 1) printf(", ");
}
printf("]\n");
}
// Print vector of strings
void print_string_vector(Vector *vec) {
printf("StringVector (size=%zu, cap=%zu): [", vec->size, vec->capacity);
for (size_t i = 0; i < vec->size; i++) {
char **str = (char**)vector_get(vec, i);
printf("\"%s\"", *str);
if (i < vec->size - 1) printf(", ");
}
printf("]\n");
}
int main() {
// Vector of integers
Vector *int_vec = vector_create(sizeof(int));
printf("=== Integer Vector ===\n");
for (int i = 1; i <= 10; i++) {
vector_push(int_vec, &i);
}
print_int_vector(int_vec);
int val = 99;
vector_insert(int_vec, 3, &val);
printf("After inserting 99 at index 3: ");
print_int_vector(int_vec);
int removed;
vector_remove(int_vec, 5, &removed);
printf("Removed %d from index 5: ", removed);
print_int_vector(int_vec);
// Vector of strings
Vector *str_vec = vector_create(sizeof(char*));
printf("\n=== String Vector ===\n");
char *strings[] = {"Hello", "World", "Dynamic", "Array", "C"};
for (int i = 0; i < 5; i++) {
vector_push(str_vec, &strings[i]);
}
print_string_vector(str_vec);
// Modify a string
char *new_str = "Modified";
vector_set(str_vec, 2, &new_str);
printf("After modifying index 2: ");
print_string_vector(str_vec);
// Clean up
vector_free(int_vec);
vector_free(str_vec);
return 0;
}

Advanced Features

1. Range Checking and Safety

typedef struct {
void *data;
size_t size;
size_t capacity;
size_t elem_size;
int (*compare)(const void*, const void*);  // For sorted operations
} SafeVector;
// Bounds-checked access
void* safe_vector_at(SafeVector *vec, size_t index) {
if (!vec || index >= vec->size) {
fprintf(stderr, "Vector index out of bounds: %zu (size: %zu)\n", 
index, vec->size);
return NULL;
}
return (char*)vec->data + index * vec->elem_size;
}
// Check if index is valid
int safe_vector_valid_index(SafeVector *vec, size_t index) {
return vec && index < vec->size;
}

2. Iterator Support

typedef struct {
Vector *vector;
size_t position;
} VectorIterator;
VectorIterator* vector_iterator(Vector *vec) {
VectorIterator *it = malloc(sizeof(VectorIterator));
if (it) {
it->vector = vec;
it->position = 0;
}
return it;
}
int vector_has_next(VectorIterator *it) {
return it && it->position < it->vector->size;
}
void* vector_next(VectorIterator *it) {
if (!vector_has_next(it)) return NULL;
void *elem = vector_get(it->vector, it->position);
it->position++;
return elem;
}
void vector_iterator_reset(VectorIterator *it) {
if (it) it->position = 0;
}
void vector_iterator_free(VectorIterator *it) {
free(it);
}
// Usage example
void iterator_demo() {
Vector *vec = vector_create(sizeof(int));
for (int i = 0; i < 10; i++) {
vector_push(vec, &i);
}
VectorIterator *it = vector_iterator(vec);
printf("Iterating: ");
while (vector_has_next(it)) {
int *val = (int*)vector_next(it);
printf("%d ", *val);
}
printf("\n");
vector_iterator_free(it);
vector_free(vec);
}

3. Sorting and Searching

#include <stdlib.h>
// Compare function for integers
int int_compare(const void *a, const void *b) {
return *(int*)a - *(int*)b;
}
// Sort the vector
void vector_sort(Vector *vec, int (*compare)(const void*, const void*)) {
if (vec && vec->size > 1) {
qsort(vec->data, vec->size, vec->elem_size, compare);
}
}
// Binary search (assumes sorted)
int vector_binary_search(Vector *vec, const void *key, 
int (*compare)(const void*, const void*)) {
if (!vec || !vec->data) return -1;
return bsearch(key, vec->data, vec->size, vec->elem_size, compare) 
? 1 : -1;
}
// Find first occurrence (linear search)
int vector_find(Vector *vec, const void *target,
int (*compare)(const void*, const void*)) {
if (!vec) return -1;
for (size_t i = 0; i < vec->size; i++) {
void *elem = (char*)vec->data + i * vec->elem_size;
if (compare(elem, target) == 0) {
return i;
}
}
return -1;
}
int main() {
Vector *vec = vector_create(sizeof(int));
int nums[] = {42, 17, 8, 99, 23, 56, 11, 34};
for (int i = 0; i < 8; i++) {
vector_push(vec, &nums[i]);
}
printf("Before sort: ");
print_int_vector(vec);
vector_sort(vec, int_compare);
printf("After sort: ");
print_int_vector(vec);
int key = 23;
int found = vector_find(vec, &key, int_compare);
printf("Found %d at index %d\n", key, found);
vector_free(vec);
return 0;
}

4. Memory Pool for Small Objects

For many small allocations, a memory pool can improve performance.

typedef struct {
Vector *vectors;      // Pool of vectors
size_t element_size;  // Size of elements in pool
size_t block_size;    // Number of elements per vector
} VectorPool;
VectorPool* pool_create(size_t element_size, size_t block_size) {
VectorPool *pool = malloc(sizeof(VectorPool));
if (!pool) return NULL;
pool->vectors = vector_create(sizeof(Vector*));
pool->element_size = element_size;
pool->block_size = block_size;
return pool;
}
void* pool_alloc(VectorPool *pool) {
// Find a vector with space
for (size_t i = 0; i < pool->vectors->size; i++) {
Vector **vec_ptr = (Vector**)vector_get(pool->vectors, i);
Vector *vec = *vec_ptr;
if (vec->size < vec->capacity) {
void *elem = malloc(pool->element_size);
vector_push(vec, elem);
return elem;
}
}
// No space found, create new block
Vector *new_block = vector_create(sizeof(void*));
vector_resize(new_block, pool->block_size);
new_block->size = 1;  // Reserve first slot
void *elem = malloc(pool->element_size);
vector_set(new_block, 0, &elem);
vector_push(pool->vectors, &new_block);
return elem;
}
void pool_free(VectorPool *pool) {
for (size_t i = 0; i < pool->vectors->size; i++) {
Vector **vec_ptr = (Vector**)vector_get(pool->vectors, i);
Vector *vec = *vec_ptr;
for (size_t j = 0; j < vec->size; j++) {
void **elem = (void**)vector_get(vec, j);
free(*elem);
}
vector_free(vec);
}
vector_free(pool->vectors);
free(pool);
}

Performance Considerations

1. Amortized Analysis

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
typedef struct {
size_t operations;
size_t resizes;
size_t total_copies;
double total_time;
} PerformanceMetrics;
void benchmark_growth_strategies() {
const int NUM_OPERATIONS = 1000000;
PerformanceMetrics metrics = {0};
printf("Benchmarking growth strategies (%d operations):\n", NUM_OPERATIONS);
// Test doubling strategy
{
Vector *vec = vector_create(sizeof(int));
clock_t start = clock();
for (int i = 0; i < NUM_OPERATIONS; i++) {
vector_push(vec, &i);
}
clock_t end = clock();
double time = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("  Doubling: %f seconds, final capacity: %zu\n", 
time, vec->capacity);
vector_free(vec);
}
// Test fixed increment (1000 at a time)
{
Vector *vec = vector_create_with_capacity(sizeof(int), 1000);
clock_t start = clock();
for (int i = 0; i < NUM_OPERATIONS; i++) {
if (vec->size >= vec->capacity) {
vector_resize(vec, vec->capacity + 1000);
}
vector_push(vec, &i);
}
clock_t end = clock();
double time = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("  Fixed +1000: %f seconds, final capacity: %zu\n", 
time, vec->capacity);
vector_free(vec);
}
}

2. Cache Locality

// Good: Sequential access (cache-friendly)
int sum_vector(Vector *vec) {
int sum = 0;
for (size_t i = 0; i < vec->size; i++) {
sum += *(int*)vector_get(vec, i);
}
return sum;
}
// Bad: Random access pattern
int sum_random(Vector *vec, size_t *indices, size_t num_indices) {
int sum = 0;
for (size_t i = 0; i < num_indices; i++) {
sum += *(int*)vector_get(vec, indices[i]);
}
return sum;
}

Common Pitfalls and Solutions

1. Forgetting to Initialize

// WRONG
Vector *vec;  // Uninitialized pointer
vector_push(vec, &value);  // Crash!
// RIGHT
Vector *vec = vector_create(sizeof(int));
if (vec) {
vector_push(vec, &value);
}

2. Memory Leaks

// WRONG - leaks inner data
void bad_free(Vector *vec) {
free(vec);  // Only frees the struct, not vec->data!
}
// RIGHT
void good_free(Vector *vec) {
free(vec->data);  // Free the array first
free(vec);        // Then free the struct
}

3. Type Punning Issues

// WRONG - assumes int size matches
Vector *vec = vector_create(sizeof(int));
double d = 3.14;
vector_push(vec, &d);  // Copies wrong size!
// RIGHT - use correct type
Vector *int_vec = vector_create(sizeof(int));
Vector *double_vec = vector_create(sizeof(double));

4. Invalid Realloc Usage

// WRONG - loses original pointer if realloc fails
vec->data = realloc(vec->data, new_size);
// If realloc fails, vec->data becomes NULL and original memory is lost!
// RIGHT
void *new_data = realloc(vec->data, new_size);
if (new_data || new_size == 0) {
vec->data = new_data;
vec->capacity = new_size;
} else {
// Handle allocation failure
fprintf(stderr, "Failed to resize vector\n");
}

Best Practices Summary

1. Always Check Return Values

Vector* vec = vector_create(sizeof(int));
if (!vec) {
// Handle allocation failure
return NULL;
}

2. Initialize to Known State

void vector_init(Vector *vec, size_t elem_size) {
vec->data = NULL;
vec->size = 0;
vec->capacity = 0;
vec->elem_size = elem_size;
}

3. Provide Cleanup Functions

void vector_destroy(Vector *vec) {
if (vec) {
free(vec->data);
// Don't free vec itself - let caller decide
}
}

4. Document Growth Strategy

/**
* Vector growth policy:
* - Initial capacity: 4 elements
* - Growth factor: 2x when full
* - Shrink when size < 1/4 capacity
*/

5. Use Assertions for Debugging

void vector_push(Vector *vec, const void *src) {
assert(vec != NULL);
assert(src != NULL);
// ... implementation
}

Conclusion

Dynamic array resizing is a fundamental technique that underlies many high-level data structures. By implementing it in C, you gain deep understanding of memory management, performance trade-offs, and the engineering decisions that go into building reusable data structures.

Key Concepts:

• Growth strategies (doubling, fixed increment) affect performance and memory usage
• Amortized analysis explains why doubling is efficient (O(1) amortized per operation)
• Generic programming with void* enables reusable data structures
• Memory management requires careful attention to allocation and deallocation
• Bounds checking prevents buffer overflows and security issues

When to Use Dynamic Arrays:

• When the number of elements is unknown at compile time
• When you need fast random access (O(1) indexing)
• When you frequently append elements
• As a building block for stacks, queues, and other data structures

When to Consider Alternatives:

• Linked lists for frequent insertions/deletions in the middle
• Fixed-size arrays when maximum size is known and small
• Specialized data structures for specific access patterns

Mastering dynamic array resizing in C provides a foundation for understanding memory management in systems programming and gives you insight into how higher-level languages implement their core data structures. It's an essential skill for any serious C programmer.