Pointers and Dynamic Memory Management

Introduction to Memory and Pointers

In C programming, a variable is a name given to a storage area that our programs can manipulate. Each variable resides at a unique location in the computer's memory, known as its memory address. While we typically interact with variables through their names (e.g., myVariable), we can also work directly with their memory addresses.

A pointer is a special type of variable that is designed to store a memory address. Instead of holding a direct value like an integer or a character, a pointer holds the location of another variable. This act of "holding the address of" is referred to as "pointing to" the variable.

Pointers are a fundamental concept in C for several reasons: they are essential for dynamic memory allocation, they allow for efficient manipulation of data and arrays, and they form the backbone of many advanced data structures.

Core Pointer Operations

To effectively use pointers, one must understand three fundamental operators:

1. The Address-Of Operator (&): This unary operator returns the memory address of a variable.

   int score = 95;
   // The expression '&score' yields the memory address where the value 95 is stored.
   

2. The Declaration Operator (*): The asterisk is used in a variable declaration to signify that the variable is a pointer. The type specified in the declaration indicates the type of variable the pointer can point to.

   int *p_score; // Declares a pointer named 'p_score' that can point to an integer.
   char *p_grade; // Declares a pointer that can point to a character.
   

   It is a common and highly recommended practice to initialize pointers to NULL if they are not immediately assigned a valid address. A NULL pointer points to nothing. int *p_score = NULL;

3. The Dereference Operator (*): Also known as the indirection operator, the asterisk is used on an already-declared pointer to access the value stored at the memory address the pointer holds.

   int score = 95;
   int *p_score = &score; // Initialization: p_score now holds the address of score.
   
   // To get the value '95' through the pointer, we dereference it:
   printf("The score is %d\n", *p_score); // This will print "The score is 95"
   

The Problem with Static Memory Allocation

When you declare a standard array in C, its size must be a constant known at compile time. This is called static memory allocation.

int readings[100]; // Memory for 100 integers is allocated when the program is compiled.

This approach has significant drawbacks in real-world applications:

• Wastefulness: If you allocate an array for 100 elements but only end up needing 20, the memory for the other 80 elements is reserved and cannot be used by any other part of your program.
• Inflexibility: If you need to store more than 100 elements, the program will fail. The only way to fix this is to modify the source code, increase the array size, and recompile the entire program. This is not a feasible solution for software that must adapt to varying amounts of data.

Dynamic Memory Allocation: The Heap

To overcome these limitations, C provides a mechanism for dynamic memory allocation. This allows a program to request memory from the operating system at runtime. This memory is allocated from a large pool of memory known as the heap. The key advantage is that the amount of memory requested can be determined while the program is running, providing flexibility and efficiency.

The functions for managing dynamic memory are available in the <stdlib.h> header file.

malloc() - Memory Allocation

The malloc function allocates a single block of memory of a specified size in bytes. It returns a void* pointer (a generic pointer) to the first byte of the allocated block.

• Syntax: void* malloc(size_t size);

• Usage: You must "cast" the returned void* to the appropriate pointer type and use the sizeof operator to ensure portability.

  int *arr;
  int n = 10;
  arr = (int*) malloc(n * sizeof(int)); // Allocate memory for 10 integers.
  

  * Error Checking: If the system cannot allocate the requested memory (e.g., it's out of memory), malloc will return NULL. It is critical to always check the return value of malloc before using the pointer.

calloc() - Contiguous Allocation

The calloc function is similar to malloc but is primarily used for allocating memory for arrays. It has two main differences: 1. It takes two arguments: the number of elements and the size of each element. 2. It initializes all bytes in the allocated memory block to zero.

• Syntax: void* calloc(size_t num_elements, size_t element_size);
• Usage:

  int *arr;
  int n = 10;
  // Allocates memory for 10 integers and initializes them all to 0.
  arr = (int*) calloc(n, sizeof(int));
  

realloc() - Re-sizing an Allocation

The realloc function is used to change the size of a previously allocated memory block. It can be used to make the block larger or smaller.

• Syntax: void* realloc(void* ptr, size_t new_size);
• Usage: It takes the original pointer and the desired new size in bytes. It may move the memory block to a new location if necessary.

• Safe Usage: If realloc fails, it returns NULL, but the original pointer (ptr) remains valid. Therefore, the return value should always be assigned to a temporary pointer.

  // arr was previously allocated for 10 ints. Now we need space for 20.
  int *temp = (int*) realloc(arr, 20 * sizeof(int));
  if (temp == NULL) {
      // Reallocation failed. The original 'arr' is still valid.
      printf("Error reallocating memory.\n");
  } else {
      // Success. Update the original pointer.
      arr = temp;
  }
  

free() - Releasing Memory

Dynamically allocated memory is not managed automatically. Once you are finished with a block of memory, you have a responsibility to release it back to the system. Failure to do so results in a memory leak, where the memory remains allocated but inaccessible, reducing the amount of memory available to the system.

• Syntax: void free(void* ptr);
• Usage: Simply pass the pointer to the memory block you wish to release.

  free(arr);
  

• Best Practice: After freeing a pointer, it's good practice to set it to NULL. This prevents a "dangling pointer"—a pointer that still holds the address of the now-released memory, which could be accidentally used later, leading to undefined behavior. arr = NULL;

---

Complete Example: A Dynamic Data Logger

The following program demonstrates the complete lifecycle of dynamic memory: allocating, using, re-sizing, and freeing.

#include <stdio.h>
#include <stdlib.h> // Required for dynamic memory functions

int main() {
    float *sensorReadings = NULL;
    int numReadings;
    int i;

    // 1. Initial Memory Allocation
    printf("Enter the initial number of sensor readings to log: ");
    scanf("%d", &numReadings);

    // Allocate memory for the specified number of float values
    sensorReadings = (float*) malloc(numReadings * sizeof(float));

    // ALWAYS check if allocation was successful
    if (sensorReadings == NULL) {
        fprintf(stderr, "Error: Initial memory allocation failed.\n");
        return 1; // Exit with an error status
    }

    printf("Memory allocated. Please enter the readings.\n");

    // 2. Using the Allocated Memory
    for (i = 0; i < numReadings; i++) {
        printf("Reading #%d: ", i + 1);
        scanf("%f", &sensorReadings[i]);
    }

    // 3. Re-sizing the Memory Block
    int moreReadings;
    printf("\nHow many more readings would you like to add? ");
    scanf("%d", &moreReadings);

    if (moreReadings > 0) {
        int newTotal = numReadings + moreReadings;
        printf("Re-allocating memory for a new total of %d readings...\n", newTotal);

        // Use a temporary pointer for safe reallocation
        float *temp = (float*) realloc(sensorReadings, newTotal * sizeof(float));

        // Check if reallocation succeeded
        if (temp == NULL) {
            fprintf(stderr, "Error: Memory reallocation failed. Original data is preserved.\n");
            // In a real application, you might try to save the original data before exiting.
        } else {
            // Reallocation was successful, update the main pointer
            sensorReadings = temp;

            // Get the new readings only
            printf("Please enter the additional readings.\n");
            for (i = numReadings; i < newTotal; i++) {
                printf("Reading #%d: ", i + 1);
                scanf("%f", &sensorReadings[i]);
            }
            // Update the total count
            numReadings = newTotal;
        }
    }

    // 4. Displaying Final Data and Freeing Memory
    printf("\n--- Final Logged Sensor Readings ---\n");
    for (i = 0; i < numReadings; i++) {
        printf("Reading #%d: %.2f\n", i + 1, sensorReadings[i]);
    }

    // Crucial step: Release the memory back to the system
    free(sensorReadings);
    sensorReadings = NULL; // Good practice to prevent dangling pointers

    printf("\nMemory has been successfully freed. Program finished.\n");

    return 0;
}