Heap Memory in C: Dynamic Management with Pointers and Valgrind

Introduction to Heap Memory and Dynamic Management

In C programming, understanding the heap is crucial for writing efficient and flexible programs. Unlike the stack, which has a fixed size, the heap allows you to allocate memory dynamically at runtime. This is especially useful when you don't know the size of data in advance—like reading a list of grades until the user enters a negative number. In this tutorial, we'll explore dynamic memory management using malloc and free, and how to use pointers to manipulate memory without array brackets. We'll also cover how to track heap usage and verify it with valgrind.

This guide is inspired by the CSCI 1730 Project 2 assignment, where you must compute the average of grades and categorize them as above, equal to, or below average—all while storing grades on the heap. We'll walk through the core concepts and provide a template you can adapt.

Why Dynamic Memory Allocation?

Imagine you're building a grade tracker for a class of unknown size—like a viral AI app that processes user data without knowing how many users will sign up. Using heap memory, you can allocate space as needed. In C, we use malloc to request a block of memory from the heap and free to release it. This is essential for dynamic data structures like linked lists or resizable arrays.

For this assignment, you must use fixed-size arrays on the heap (e.g., sizes of 40, 80, 120, …) and grow them as needed. This simulates real-world scenarios where you allocate memory in chunks to balance efficiency and overhead.

Pointer Arithmetic vs. Array Notation

One key requirement is to avoid using square brackets [ ] for arrays. Instead, you'll use pointer arithmetic. For example, instead of arr[i], you write *(arr + i). This reinforces how arrays are really pointers under the hood. If you have a pointer int *grades, then grades + i moves the pointer by i * sizeof(int) bytes, and dereferencing it gives the value.

Here's a snippet showing how to allocate and access memory using pointers:

int *grades = (int*) malloc(40 * sizeof(int));
if (grades == NULL) { /* handle error */ }
*(grades + 0) = 85;  // first grade
int first = *(grades + 0);

Notice we cast the return of malloc to int*—this is optional in modern C but good practice. Always check if malloc returns NULL, indicating memory allocation failure.

Resizing the Heap Array

Since you don't know the number of grades beforehand, you'll start with an initial block (e.g., 40 integers) and when it's full, allocate a larger block (e.g., 80), copy the data, and free the old one. This is similar to how std::vector works in C++. Use realloc? The assignment restricts you to malloc and free only—so you must manually copy. For example:

int new_size = current_size + 40;
int *new_grades = (int*) malloc(new_size * sizeof(int));
if (new_grades == NULL) { /* handle error */ }
// copy old data
for (int i = 0; i < current_count; i++) {
    *(new_grades + i) = *(old_grades + i);
}
free(old_grades);
old_grades = new_grades;
current_size = new_size;

This ensures no memory leaks—you free the old block before reassigning the pointer.

Tracking Heap Usage

Your program must output total heap usage that matches valgrind's report. Valgrind tracks how many bytes were allocated and freed. To get consistent output, you need to calculate the total bytes allocated (sum of all malloc sizes) and total bytes freed (sum of all free sizes). The difference should be zero at the end (no leaks).

For example, if you allocate 40 ints (160 bytes) then later allocate 80 ints (320 bytes) and free the first 160, your total allocated is 480 bytes, total freed is 160 bytes, and at the end you free the last 320 bytes. Valgrind will show something like: total heap usage: 3 allocs, 3 frees, 480 bytes allocated. Your program should print a similar line.

Computing the Average and Categorizing Grades

After reading all grades (stop when input is negative), compute the average as a double. Then iterate through the list and print each grade with its relation to the average: above, equal, or below. Use pointer arithmetic to traverse the array.

Here's a template for the loop:

double avg = (double) sum / count;
for (int i = 0; i < count; i++) {
    int grade = *(grades + i);
    if (grade > avg) {
        printf("%d is above average\n", grade);
    } else if (grade == avg) {
        printf("%d is equal to average\n", grade);
    } else {
        printf("%d is below average\n", grade);
    }
}

Remember: avg is a double, so comparing grade == avg may be tricky due to floating-point precision. In the assignment, the average is likely a whole number (since grades are integers and the sum is divisible by count), but if not, you might need to check within a tolerance. However, the examples probably ensure integer averages.

Memory Leak Prevention and Valgrind

To avoid memory leaks, every malloc must eventually have a matching free. In this program, you'll free the final array before exiting. Also, if you allocate intermediate arrays during resizing, free the old ones immediately after copying. Run your program under valgrind: valgrind --leak-check=full ./proj2. Valgrind will report any leaks or mismatched allocs/frees.

Common pitfalls:

Not freeing memory when you reassign a pointer (losing the reference).
Allocating with malloc but forgetting to check for NULL.
Using realloc or other forbidden functions.
Using array brackets [ ] anywhere in the source.

Complete Example Walkthrough

Suppose the input is: 85 90 78 92 88 -1. Your program should:

Allocate initial array of 40 ints (160 bytes).
Read grades: 85, 90, 78, 92, 88. Count = 5.
Compute sum = 433, average = 86.6.
Print each grade and its relation: 85 below, 90 above, 78 below, 92 above, 88 above.
Print heap usage: e.g., Total heap usage: 1 alloc, 1 free, 160 bytes allocated.

If the input has more than 40 grades, you'll resize. For example, with 50 grades: allocate 40, fill 40, then allocate 80, copy, free 40, continue reading next 10.

SEO Keywords and Trends

This topic is highly relevant for computer science students. To connect with current trends, think of AI memory management in large language models or dynamic memory in gaming engines like Unreal Engine. Even in finance, high-frequency trading systems rely on efficient heap allocation. By mastering these concepts, you're building skills used in operating systems, embedded systems, and data science pipelines.

Conclusion

Dynamic memory management in C is a foundational skill. By avoiding array brackets and using pointer arithmetic, you gain deeper insight into how memory works. Always pair malloc with free, verify with valgrind, and structure your code to handle unknown input sizes. This approach not only satisfies assignment requirements but also prepares you for real-world C programming.

For more practice, try implementing a dynamic array that stores strings or structures. The same principles apply: allocate, resize, and free meticulously.