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:

Allocates memory on the heap (not the stack)
Tracks its capacity (total allocated space)
Tracks its size (currently used elements)
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.

Complete C Programming Guide + Compilers Collection

1. C srand() Function – Understanding Seed Initialization

https://macronepal.com/understanding-the-c-srand-function
Explains how srand() initializes the pseudo-random number generator in C by setting a seed value. Using the same seed produces the same sequence, while time(NULL) gives different results each run.

2. C rand() Function Mechanics and Limitations

https://macronepal.com/c-rand-function-mechanics-and-limitations
Explains how rand() generates pseudo-random numbers between 0 and RAND_MAX, its deterministic nature, and limitations for security use cases.

3. C log() Function

https://macronepal.com/c-log-function-2
Covers natural logarithm calculation using <math.h> and its applications.

4. Mastering Date and Time in C

https://macronepal.com/mastering-date-and-time-in-c
Explains <time.h> functions like time(), clock(), difftime(), and struct tm.

5. Mastering time_t Type in C

https://macronepal.com/mastering-the-c-time_t-type-for-time-management
Explains time representation as seconds since Unix epoch and conversion functions.

6. C exp() Function

https://macronepal.com/c-exp-function-mechanics-and-implementation
Explains exponential function exp(x) and its scientific applications.

7. C log() Function (Alternate Guide)

https://macronepal.com/c-log-function
Comparison of log() and log10() with usage examples.

8. C log10() Function

https://macronepal.com/mastering-the-log10-function-in-c
Explains base-10 logarithm for engineering and scientific applications.

9. C tan() Function

https://macronepal.com/understanding-the-c-tan-function
Explains tangent function and radian-based calculations.

10. Random Numbers in C (Secure vs Predictable)

https://macronepal.com/mastering-c-random-numbers-for-secure-and-predictable-applications
Explains difference between rand() and secure randomness methods.

11. Free Online C Compiler

https://macronepal.com/free-online-c-code-compiler-2
Browser-based compiler for testing C programs instantly.

C Functions, Arguments, Parameters & Flow

Mastering Functions in C – Complete Guide

https://macronepal.com/c/mastering-functions-in-c-a-complete-guide/
Covers function structure, modular programming, and real-world usage.

Function Arguments in C

https://macronepal.com/c-function-arguments/
Explains how arguments are passed and used in function calls.

Function Parameters in C

https://macronepal.com/c-function-parameters/
Explains defining inputs for functions and matching them with arguments.

Function Declarations in C

https://macronepal.com/c-function-declarations-syntax-rules-and-best-practices/
Covers prototypes, syntax rules, and best practices.

Function Calls in C

https://macronepal.com/understanding-function-calls-in-c-syntax-mechanics-and-best-practices/
Explains execution flow and parameter handling during function calls.

Void Functions in C

https://macronepal.com/understanding-void-functions-in-c-syntax-patterns-and-best-practices/
Explains functions that do not return values.

Return Values in C

https://macronepal.com/c-return-values-mechanics-types-and-best-practices/
Explains different return types and how functions return results.

Pass-by-Value in C

https://macronepal.com/aws/understanding-pass-by-value-in-c-mechanics-implications-and-best-practices/
Explains how copies of variables are passed into functions.

Pass-by-Reference in C

https://macronepal.com/c/understanding-pass-by-reference-in-c-pointers-semantics-and-safe-practices/
Explains using pointers to modify original variables.

C strstr() Function

https://macronepal.com/aws/c-strstr-function/
Explains substring search inside strings in C.

C Preprocessor & Macros

C Structures, Memory, Scope & Linkage

C Scope, Storage Classes & Typedef

Extra Articles

https://macronepal.com/13757-2/
https://macronepal.com/13748-2/
https://macronepal.com/13747-2/
https://macronepal.com/13746-2/
https://macronepal.com/13745-2/
https://macronepal.com/13708-2/
https://macronepal.com/13707-2/
https://macronepal.com/13702-2/

Online Compilers