Mastering C Programming: A Complete Tutorial for Beginners and Beyond

📘 Chapter 5: Pointers and Memory Management in C

🧠 Introduction

One of the defining features of C—and a major reason for its power—is its use of pointers. Pointers allow direct access to memory addresses, enabling powerful features such as dynamic memory allocation, array manipulation, and efficient parameter passing to functions.

This chapter explores:

• What pointers are
• How they are used in programs
• Dynamic memory allocation
• Memory deallocation and leaks
• Common pitfalls

🔍 What is a Pointer?

A pointer is a variable that stores the memory address of another variable.

✅ Syntax:

data_type *pointer_name;

✅ Example:

int a = 10;

int *p = &a;

In this example:

• a is an integer variable.
• p is a pointer to an integer.
• &a gets the address of a.
• *p dereferences the pointer to access the value.

🧾 Pointer Terminology

🔢 Declaring and Using Pointers

✅ Declare a pointer:

int *ptr;

✅ Assign address to pointer:

int x = 5;

ptr = &x;

✅ Dereference to access value:

printf("%d", *ptr);  // Output: 5

📋 Table: Pointer Examples

🔁 Pointer Arithmetic

Pointer arithmetic depends on data type size.

int a = 10, b = 20;

int *p = &a;

p++;  // now points to next int (typically +4 bytes)

🧰 Pointers and Arrays

An array name is essentially a constant pointer.

int arr[3] = {10, 20, 30};

int *ptr = arr;

printf("%d", *(ptr + 1));  // Output: 20

You can iterate using pointer arithmetic:

for (int i = 0; i < 3; i++) {

    printf("%d ", *(ptr + i));

}

🔁 Pointer to Pointer (Double Pointer)

A pointer that stores the address of another pointer.

int a = 10;

int *p = &a;

int **q = &p;

printf("%d", **q);  // Output: 10

📦 Pointers and Functions

✅ Passing by reference using pointers:

void update(int *x) {

    *x = *x + 10;

}

int main() {

    int num = 5;

    update(&num);

    printf("%d", num); // Output: 15

}

This allows us to modify the original variable inside a function.

🔃 Dynamic Memory Allocation

Dynamic memory allows allocation during runtime using standard library functions in <stdlib.h>.

✅ malloc() – Memory Allocation

int *p = (int*) malloc(sizeof(int) * 5);

• Allocates memory for 5 integers
• Returns void* that’s typecasted to int*
• Uninitialized memory

✅ calloc() – Contiguous Allocation

int *p = (int*) calloc(5, sizeof(int));

• Allocates memory for 5 integers
• Initializes all bytes to zero

✅ realloc() – Resize Memory Block

p = (int*) realloc(p, sizeof(int) * 10);

• Resizes previously allocated memory

✅ free() – Free Memory

free(p);

• Frees dynamically allocated memory

📋 Comparison Table – Memory Allocation Functions

⚠️ Common Pointer Issues

🔹 Dangling Pointer

int *ptr = (int*) malloc(sizeof(int));

free(ptr);

// Now ptr is dangling; points to deallocated memory

🔹 Memory Leak

Memory allocated but never freed.

int *p = (int*) malloc(100);

p = NULL;  // Leak! Previous memory is lost

🔹 Null Pointer Dereference

int *p = NULL;

printf("%d", *p);  // Crash

🧪 Sample Program: Dynamic Array Input

#include <stdio.h>

#include <stdlib.h>

int main() {

    int n, *arr;

    printf("Enter size of array: ");

    scanf("%d", &n);

    arr = (int*) malloc(n * sizeof(int));

    printf("Enter elements:\n");

    for (int i = 0; i < n; i++) {

        scanf("%d", &arr[i]);

    }

    printf("You entered:\n");

    for (int i = 0; i < n; i++) {

        printf("%d ", arr[i]);

    }

    free(arr);

    return 0;

}

🧠 Real-World Use Cases

📋 Chapter Summary