Pointers and Dynamic Memory in C

Correct answer from the quiz: p receives the memory address of x.

Dereferencing a Null Pointer

Consider the declaration char *p = NULL;. The pointer p does not point to any valid memory location. Attempting to write *p = 'A'; tries to store a character at address 0, which is undefined behavior. The operating system typically protects low memory addresses, so the program will likely crash (segmentation fault) or exhibit unpredictable results.

Key takeaway: Never dereference a null pointer. Always allocate memory or assign a valid address before using *p.

Passing Pointers to Functions

Functions can receive pointers as parameters, allowing them to modify the original variables. For example:

void incrementer(int *x) {
    *x = *x + 1;
}

If a is initially 5 and we call incrementer(&a);, the function receives the address of a. Inside the function, *x refers to a itself, so the statement increments its value to 6. After the call, a holds 6.

Correct answer from the quiz: 6.

Pointer Arithmetic

When you add an integer to a pointer, the result is the original address plus the integer multiplied by the size of the pointed‑to type. This is why p + 1 does not simply add one byte.

Example: If p is a long int * and holds the address 1230, then p + 1 points to 1230 + sizeof(long int). Assuming sizeof(long int) = 8 bytes, the new address is 1238.

Correct answer from the quiz: Address 1238 (adds sizeof(long int)).

Dynamic Memory Allocation

C provides three primary functions for managing heap memory:

• malloc(size_t size) – allocates size bytes; contents are indeterminate.
• calloc(size_t count, size_t size) – allocates count * size bytes and initializes them to zero.
• realloc(void *ptr, size_t new_size) – changes the size of an existing block, possibly moving it.

When you are finished with a block, you must free it with free(void *ptr). After freeing, the pointer becomes a dangling reference unless you set it to NULL.

Freeing Memory Safely

After calling free(p);, the memory previously pointed to by p is returned to the system, but p still contains the old address. Setting p = NULL; immediately after freeing eliminates the risk of accidental dereferencing, because a null pointer is easy to test and will cause a clear runtime error if used.

Correct answer from the quiz: p is a null pointer and must not be dereferenced.

Allocating and Initializing an Array

To allocate memory for an array of ten int elements and ensure all elements start at zero, the most straightforward approach is to use calloc:

int *arr = calloc(10, sizeof(int));

calloc automatically zero‑initializes the allocated block. Using malloc would require an explicit loop or memset to achieve the same effect.

Correct answer from the quiz: int *arr = calloc(10, sizeof(int));.

Reallocating Without a Temporary Pointer

The realloc function may fail, returning NULL while leaving the original memory block untouched. If you write p = realloc(p, new_size); and realloc fails, you lose the original pointer value, creating a memory leak because you can no longer free the original block.

Best practice: use a temporary pointer.

int *tmp = realloc(p, new_size);
if (tmp) {
    p = tmp; // success
} else {
    // handle error, original p is still valid
}

Correct answer from the quiz: If realloc fails, the original pointer is lost causing a memory leak.

Arrays and Pointers in Function Parameters

When an array is passed to a function, it decays to a pointer to its first element. Therefore, the parameter int *p in void foo(int *p) points to t[0], the first element of the original array.

Correct answer from the quiz: The first element of the array.

Best Practices for Safe Pointer Usage

• Initialize pointers to NULL when declared.
• Check the result of malloc, calloc, and realloc before using the returned pointer.
• Never dereference a null pointer; always ensure the pointer points to a valid memory block.
• Free allocated memory when it is no longer needed, and set the pointer to NULL afterwards.
• Use temporary pointers with realloc to avoid losing the original block on failure.
• Prefer calloc when you need zero‑initialized memory.
• Document ownership of dynamically allocated memory to avoid double frees or leaks.

Summary

This course covered the essential concepts of pointers and dynamic memory in C, including address assignment, dereferencing, pointer arithmetic, safe allocation, and deallocation. Mastery of these topics is crucial for writing robust, efficient C programs and for understanding how higher‑level languages manage memory under the hood.