Pointers in C
Learn pointers using simple analogies and visual diagrams — no more confusion about * and &!
🤔 What is a Pointer? (Simple Analogies)
💡 Analogy 1: The Mailbox
Imagine a variable is like a mailbox at your house:
🏠 Your House (Memory)
┌─────────────────────────────────────────────────────────┐
│ │
│ Mailbox #42 Mailbox #50 │
│ ┌──────────┐ ┌──────────┐ │
│ │ 📬 #42 │ │ 📬 #50 │ │
│ │ Value: │ │ Value: │ │
│ │ 100 │ │ 0x002A │ ← This is a │
│ │ (int) │ │ (address)│ POINTER! │
│ └──────────┘ └──────────┘ │
│ ↑ │ │
│ │ │ │
│ Regular Variable Pointer Variable │
│ (stores a number) (stores an address) │
│ │
│ The pointer at #50 "points to" mailbox #42! │
│ │
└─────────────────────────────────────────────────────────┘
Key Insight:
• A regular variable stores a VALUE (like 100)
• A pointer variable stores an ADDRESS (like 0x002A = #42)
🗺️ Analogy 2: The Treasure Map
A pointer is like a treasure map:
🗺️ Treasure Map Analogy
┌─────────────────────────────────────────────────────────┐
│ │
│ Treasure Chest (Variable) Treasure Map │
│ ┌──────────────┐ ┌──────────────┐ │
│ │ 💎💎💎💎💎 │ │ 🗺️ MAP │ │
│ │ │ │ │ │
│ │ Location: │ │ "Go to the │ │
│ │ Old Oak Tree │ │ Old Oak │ │
│ │ │ │ Tree" │ │
│ │ Contents: │◄───────────────│ │ │
│ │ 500 Gold │ Points to │ Address: │ │
│ └──────────────┘ │ "Old Oak" │ │
│ └──────────────┘ │
│ │
│ The map doesn't HAVE the treasure — it tells you │
│ WHERE to find it! │
│ │
│ Similarly, a pointer doesn't HAVE the value — │
│ it tells you WHERE the value is stored! │
│ │
└─────────────────────────────────────────────────────────┘
🏷️ Analogy 3: The Label on a Box
Think of memory like a storage unit facility:
🏭 Storage Facility (Memory)
┌─────────────────────────────────────────────────────────┐
│ │
│ Unit A-12 Unit B-05 │
│ ┌────────────┐ ┌────────────┐ │
│ │ 📦 Unit │ │ 📦 Unit │ │
│ │ A-12 │ │ B-05 │ │
│ │ │ │ │ │
│ │ Contents: │ │ Contents: │ │
│ │ "Bicycle" │ │ "See A-12" │ ← This is a │
│ └────────────┘ └────────────┘ pointer! │
│ ▲ │ │
│ │ │ │
│ └──────────────────────┘ │
│ │
│ Unit B-05 contains directions to Unit A-12! │
│ If you follow the directions, you find the bike. │
│ │
└─────────────────────────────────────────────────────────┘
Summary: A pointer is a variable that stores a memory address instead of a regular value. It "points to" another location in memory where the actual data lives.
💾 Visual Memory Diagrams
📊 How Memory Actually Looks
Let's see what happens when we create a variable and a pointer:
BEFORE: Creating Variables
Code: int num = 42;
Memory Layout:
┌─────────────────────────────────────────────────────────┐
│ Address Variable Value Type │
├─────────────────────────────────────────────────────────┤
│ 0x1000 num 42 int │
│ 0x1004 (empty) - - │
│ 0x1008 (empty) - - │
│ 0x100C (empty) - - │
│ ... ... ... ... │
└─────────────────────────────────────────────────────────┘
The computer assigns address 0x1000 to variable 'num'
It stores the value 42 at that location
AFTER: Creating a Pointer
Code: int *ptr = #
Memory Layout:
┌─────────────────────────────────────────────────────────┐
│ Address Variable Value Type/Notes │
├─────────────────────────────────────────────────────────┤
│ 0x1000 num 42 int │
│ ▲ │
│ │ │
│ 0x1004 │ ptr 0x1000 int* (pointer) │
│ │ ↑ │
│ │ │ │
│ └──────────────┘ │
│ ptr stores the address of num! │
│ 0x1008 (empty) - - │
│ 0x100C (empty) - - │
└─────────────────────────────────────────────────────────┘
ptr is a pointer variable that lives at 0x1004
It stores the value 0x1000 (which is num's address)
We say "ptr points to num"
🔄 Step-by-Step: Pointer Assignment
Step-by-Step: What happens with each line?
┌─────────────────────────────────────────────────────────┐
│ Code: int num = 100; │
│ │
│ Memory: ┌─────────┐ │
│ Address │ Value │ │
│ 0x1000 │ 100 │ ← num lives here │
│ └─────────┘ │
├─────────────────────────────────────────────────────────┤
│ Code: int *ptr = # │
│ │
│ Memory: ┌─────────┐ ┌─────────┐ │
│ Address │ Value │ │ Value │ │
│ 0x1000 │ 100 │◄───│ 0x1000 │ │
│ │ num │ │ ptr │ │
│ └─────────┘ └─────────┘ │
│ ↑ │
│ ptr stores num's address │
├─────────────────────────────────────────────────────────┤
│ Code: *ptr = 200; ← Dereferencing! │
│ │
│ What happens: │
│ 1. *ptr means "go to the address stored in ptr" │
│ 2. ptr has 0x1000, so go to address 0x1000 │
│ 3. Change the value at 0x1000 to 200 │
│ │
│ Memory: ┌─────────┐ ┌─────────┐ │
│ Address │ Value │ │ Value │ │
│ 0x1000 │ 200 │◄───│ 0x1000 │ │
│ │ num │ │ ptr │ │
│ └─────────┘ └─────────┘ │
│ │
│ Now num = 200! We changed it through the pointer! │
└─────────────────────────────────────────────────────────┘
🎯 Understanding * and & Operators
📍 The & (Address-of) Operator
& means "get the address of" — it's like asking "where does this variable live?"
& (Address-of) Explained
┌─────────────────────────────────────────────────────────┐
│ │
│ int score = 95; │
│ │
│ ┌─────────────────────────────────────────┐ │
│ │ &score → "Where is score stored?" │ │
│ │ │ │
│ │ Answer: 0x1000 (or some address) │ │
│ └─────────────────────────────────────────┘ │
│ │
│ Think of it like: │
│ "What's the address of score's house?" │
│ "Where in memory does score live?" │
│ │
└─────────────────────────────────────────────────────────┘
Example:
int num = 42;
printf("%p", &num); // Prints something like 0x7ffe1234
⭐ The * (Dereference) Operator
* means "go to the address" or "get the value at" — it's like following a treasure map!
* (Dereference) Explained
┌─────────────────────────────────────────────────────────┐
│ │
│ int num = 42; │
│ int *ptr = # // ptr = address of num │
│ │
│ ┌─────────────────────────────────────────┐ │
│ │ *ptr → "Go to the address in ptr" │ │
│ │ │ │
│ │ ptr has &num (address 0x1000) │ │
│ │ *ptr means: Go to 0x1000 and get value │ │
│ │ Answer: 42 │ │
│ └─────────────────────────────────────────┘ │
│ │
│ Think of it like: │
│ "Follow the map to find the treasure!" │
│ "Go to that address and tell me what's there" │
│ │
└─────────────────────────────────────────────────────────┘
Example:
int num = 42;
int *ptr = #
printf("%d", *ptr); // Prints 42 (the value at that address)
😵 Common Confusion: * in Declaration vs * in Usage
This trips everyone up! The same symbol * does different things:
CRITICAL DISTINCTION: * in different contexts
┌─────────────────────────────────────────────────────────┐
│ │
│ Context 1: DECLARATION (Creating a pointer) │
│ ═══════════════════════════════════════════ │
│ │
│ int *ptr; │
│ ↑ │
│ This * says "ptr is a POINTER to int" │
│ │
│ → This creates a new pointer variable │
│ → It's part of the TYPE declaration │
│ │
├─────────────────────────────────────────────────────────┤
│ │
│ Context 2: USAGE (Dereferencing a pointer) │
│ ═══════════════════════════════════════════ │
│ │
│ *ptr = 100; │
│ ↑ │
│ This * says "go to address stored in ptr" │
│ │
│ → This ACCESS/CHANGES the value being pointed to │
│ → It's an OPERATION on an existing pointer │
│ │
├─────────────────────────────────────────────────────────┤
│ │
│ Side-by-Side Comparison: │
│ │
│ int *p = &x; ← * in declaration │
│ // ↑ │
│ // "p is a pointer to int" │
│ │
│ *p = 50; ← * in usage │
│ //↑ │
│ // "Go to the address in p and put 50 there" │
│ │
│ int y = *p; ← * in usage │
│ // ↑ │
│ // "Go to the address in p and get the value" │
│ │
│ Memory Aid: │
│ • Declaration * = "This is a pointer" 📝 │
│ • Usage * = "Follow the pointer" 🚶 │
│ │
└─────────────────────────────────────────────────────────┘
📝 Your First Pointer Example
📊 Step-by-Step Execution Trace
Watch how memory changes with each line:
Code Trace: first_pointer.c
┌─────────────────────────────────────────────────────────┐
│ Line 1: int num = 10; │
│ │
│ Memory: │
│ ┌─────────────────┐ │
│ │ Address: 0x1000 │ │
│ │ num = 10 │ │
│ └─────────────────┘ │
│ │
├─────────────────────────────────────────────────────────┤
│ Line 2: int *ptr = # │
│ │
│ Memory: │
│ ┌─────────────────┐ ┌─────────────────┐ │
│ │ Address: 0x1000 │ │ Address: 0x1004 │ │
│ │ num = 10 │◄───│ ptr = 0x1000 │ │
│ └─────────────────┘ └─────────────────┘ │
│ ↑ │
│ ptr "points to" num │
│ │
├─────────────────────────────────────────────────────────┤
│ Line 3: printf("%d", *ptr); │
│ │
│ Output: 10 │
│ Why? *ptr means "go to 0x1000, get value" → 10 │
│ │
├─────────────────────────────────────────────────────────┤
│ Line 4: *ptr = 20; │
│ │
│ Memory: │
│ ┌─────────────────┐ ┌─────────────────┐ │
│ │ Address: 0x1000 │ │ Address: 0x1004 │ │
│ │ num = 20 ←──────┘◄───│ ptr = 0x1000 │ │
│ └─────────────────┘ └─────────────────┘ │
│ We changed num THROUGH the pointer! │
│ │
├─────────────────────────────────────────────────────────┤
│ Line 5: printf("%d", num); │
│ │
│ Output: 20 │
│ Even though we didn't touch num directly! │
│ │
└─────────────────────────────────────────────────────────┘
first_pointer.c
#include <stdio.h>
int main() {
// Step 1: Create a regular variable
int num = 10;
printf("1. num = %d\n", num); // Output: 10
// Step 2: Create a pointer that points to num
int *ptr = #
printf("2. &num = %p\n", (void*)&num); // Address of num
printf("3. ptr = %p\n", (void*)ptr); // Same address!
// Step 3: Access value through pointer (dereferencing)
printf("4. *ptr = %d\n", *ptr); // Output: 10
// Step 4: Change value through pointer
*ptr = 20;
printf("5. After *ptr = 20:\n");
printf(" num = %d\n", num); // Output: 20
printf(" *ptr = %d\n", *ptr); // Output: 20
// Step 5: Change num directly
num = 30;
printf("6. After num = 30:\n");
printf(" num = %d\n", num); // Output: 30
printf(" *ptr = %d\n", *ptr); // Output: 30
return 0;
}➕ Pointer Arithmetic Visualized
📊 Why ptr + 1 Doesn't Just Add 1
Pointer arithmetic is smart — it knows the size of what it points to!
Pointer Arithmetic Explained
┌─────────────────────────────────────────────────────────┐
│ Array: int arr[5] = {10, 20, 30, 40, 50}; │
│ │
│ Memory Layout (int = 4 bytes): │
│ ┌─────────┬─────────┬─────────┬─────────┬─────────┐ │
│ │arr[0] │arr[1] │arr[2] │arr[3] │arr[4] │ │
│ │ 10 │ 20 │ 30 │ 40 │ 50 │ │
│ │ │ │ │ │ │ │
│ │ 0x1000 │ 0x1004 │ 0x1008 │ 0x100C │ 0x1010 │ │
│ └────┬────┴─────────┴─────────┴─────────┴─────────┘ │
│ │ │
│ └─ ptr = &arr[0] = 0x1000 │
│ │
│ Now let's do pointer arithmetic: │
│ │
│ ┌─────────────────────────────────────────────────────┐│
│ │ Expression │ Calculation │ Result ││
│ ├─────────────────────────────────────────────────────┤│
│ │ ptr │ 0x1000 │ Points to arr[0] ││
│ │ ptr + 1 │ 0x1000 + 4 │ Points to arr[1] ││
│ │ ptr + 2 │ 0x1000 + 8 │ Points to arr[2] ││
│ │ ptr + 3 │ 0x1000 + 12 │ Points to arr[3] ││
│ └─────────────────────────────────────────────────────┘│
│ │
│ Key Insight: ptr + 1 adds sizeof(int) = 4 bytes! │
│ │
│ Why? Because ptr knows it's an "int*" pointer! │
│ It automatically multiplies by sizeof(int) │
│ │
│ ┌─────────────────────────────────────────────────────┐│
│ │ What you write │ What actually happens ││
│ ├─────────────────────────────────────────────────────┤│
│ │ ptr + 1 │ ptr + (1 × sizeof(int)) ││
│ │ │ ptr + (1 × 4) = ptr + 4 ││
│ │ ││
│ │ ptr + 3 │ ptr + (3 × sizeof(int)) ││
│ │ │ ptr + (3 × 4) = ptr + 12 ││
│ └─────────────────────────────────────────────────────┘│
│ │
│ This is why *(ptr + 1) gives you arr[1], not garbage! │
└─────────────────────────────────────────────────────────┘
🔄 Visual Array Traversal
Array Traversal with Pointer Arithmetic
int arr[] = {10, 20, 30, 40, 50};
int *ptr = arr; // ptr points to arr[0]
┌─────────────────────────────────────────────────────────┐
│ │
│ Initial State: │
│ ┌─────┬─────┬─────┬─────┬─────┐ │
│ │ 10 │ 20 │ 30 │ 40 │ 50 │ │
│ └──┬──┴─────┴─────┴─────┴─────┘ │
│ ↑ │
│ ptr │
│ │
│ Iteration 1: printf("%d", *ptr); → Prints 10 │
│ ptr++; │
│ ┌─────┬─────┬─────┬─────┬─────┐ │
│ │ 10 │ 20 │ 30 │ 40 │ 50 │ │
│ └─────┷──┬──┴─────┴─────┴─────┘ │
│ ↑ │
│ ptr │
│ │
│ Iteration 2: printf("%d", *ptr); → Prints 20 │
│ ptr++; │
│ ┌─────┬─────┬─────┬─────┬─────┐ │
│ │ 10 │ 20 │ 30 │ 40 │ 50 │ │
│ └─────┴─────┷──┬──┴─────┴─────┘ │
│ ↑ │
│ ptr │
│ │
│ And so on... │
│ │
└─────────────────────────────────────────────────────────┘
pointer_arithmetic.c
#include <stdio.h>
int main() {
int arr[] = {10, 20, 30, 40, 50};
int *ptr = arr; // Points to first element
int n = 5;
printf("Array elements using pointer arithmetic:\n");
for (int i = 0; i < n; i++) {
printf("*(ptr + %d) = %d\n", i, *(ptr + i));
}
printf("\nUsing ptr++ to move through array:\n");
ptr = arr; // Reset to beginning
for (int i = 0; i < n; i++) {
printf("*ptr = %d, ptr = %p\n", *ptr, (void*)ptr);
ptr++; // Move to next element
}
// Arrays and pointers are closely related!
printf("\nArray[i] is the same as *(array + i):\n");
for (int i = 0; i < n; i++) {
printf("arr[%d] = %d, *(arr + %d) = %d\n",
i, arr[i], i, *(arr + i));
}
return 0;
}📍 Pointer to Pointer (Double Pointer)
💡 The "Address of an Address"
A pointer to a pointer is like a map to a map!
Pointer to Pointer Visual
┌─────────────────────────────────────────────────────────┐
│ │
│ int num = 42; │
│ int *ptr = # // ptr points to num │
│ int **pptr = &ptr; // pptr points to ptr │
│ │
│ Memory Diagram: │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Address 0x1000: num = 42 │ │
│ │ ↑ │ │
│ │ │ │ │
│ │ Address 0x1004: ptr = 0x1000 ←───┐ │ │
│ │ ↑ │ │ │
│ │ │ │ │ │
│ │ Address 0x1008: pptr = 0x1004 ──┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ Accessing Values: │
│ ┌─────────────────────────────────────────────────┐ │
│ │ Expression │ Meaning │ Result │ │
│ ├─────────────────────────────────────────────────┤ │
│ │ num │ Direct value │ 42 │ │
│ │ *ptr │ Follow ptr once │ 42 │ │
│ │ **pptr │ Follow pptr twice │ 42 │ │
│ │ ptr │ Address of num │ 0x1000 │ │
│ │ *pptr │ Address of num │ 0x1000 │ │
│ │ pptr │ Address of ptr │ 0x1004 │ │
│ │ &pptr │ Address of pptr │ 0x1008 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘
pointer_to_pointer.c
#include <stdio.h>
int main() {
int num = 42;
int *ptr = # // Pointer to int
int **pptr = &ptr; // Pointer to pointer
printf("Value of num: %d\n", num);
printf("Value of *ptr: %d\n", *ptr);
printf("Value of **pptr: %d\n", **pptr);
printf("\nAddress of num: %p\n", (void*)&num);
printf("Value of ptr: %p\n", (void*)ptr);
printf("Value of *pptr: %p\n", (void*)*pptr);
printf("\nAddress of ptr: %p\n", (void*)&ptr);
printf("Value of pptr: %p\n", (void*)pptr);
// Modify through double pointer
**pptr = 100;
printf("\nAfter **pptr = 100, num = %d\n", num);
return 0;
}🔗 Arrays and Pointers Relationship
💡 The Key Insight
In C, array names are essentially pointers to the first element!
Array Name as Pointer
int arr[5] = {10, 20, 30, 40, 50};
int *ptr = arr; // Same as: int *ptr = &arr[0];
┌─────────────────────────────────────────────────────────┐
│ │
│ Memory Layout: │
│ ┌─────┬─────┬─────┬─────┬─────┐ │
│ │ 10 │ 20 │ 30 │ 40 │ 50 │ │
│ └──┬──┴─────┴─────┴─────┴─────┘ │
│ │ │
│ ├─ arr (the array name points here) │
│ │ │
│ └─ ptr (our pointer also points here) │
│ │
│ Equivalence Table: │
│ ┌─────────────────────────────────────────────────┐ │
│ │ Array Notation │ Pointer Notation │ Value │ │
│ ├─────────────────────────────────────────────────┤ │
│ │ arr[0] │ *arr or *ptr │ 10 │ │
│ │ arr[1] │ *(arr+1) or *(ptr+1)│ 20 │ │
│ │ arr[2] │ *(arr+2) or *(ptr+2)│ 30 │ │
│ │ arr[i] │ *(arr+i) or *(ptr+i)│ ... │ │
│ │ &arr[0] │ arr or ptr │ address │ │
│ │ &arr[i] │ arr+i or ptr+i │ address │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ Important Differences: │
│ • arr is a CONSTANT pointer (can't do arr++) │
│ • ptr is a VARIABLE pointer (can do ptr++) │
│ • sizeof(arr) gives total array size │
│ • sizeof(ptr) gives pointer size (4 or 8 bytes) │
│ │
└─────────────────────────────────────────────────────────┘
⚠️ Common Pointer Mistakes
| Mistake | Problem | Correct Code | Visual |
|---|---|---|---|
| Uninitialized Pointer | Pointer points to random memory | int *p = NULL;// orint *p = &x; |
ptr → ??? (Dangerous!) |
| NULL Pointer Dereference | Trying to access NULL pointer | if (p != NULL) *p = 10; |
ptr → NULL Check first! |
| Dangling Pointer | Pointing to freed memory | free(ptr);ptr = NULL; |
ptr → [FREED] Set to NULL! |
| Memory Leak | Allocated memory not freed | int *p = malloc(...);// use p...free(p); |
malloc → use → free Don't forget! |
| Confusing * and & | Using wrong operator | // Get address: &x// Get value: *p |
& = "where" * = "what's there" |
| Pointer Type Mismatch | Wrong pointer type | int *ip;char *cp;// Don't mix! |
int* vs char* Different sizes! |
🚨 Uninitialized Pointer Danger
❌ DANGEROUS: Uninitialized Pointer
int *ptr; // ptr contains GARBAGE address!
*ptr = 10; // Writing to random memory!
┌─────────────────────────────────────────────────────────┐
│ │
│ Memory: │
│ │
│ ptr = ??? (could be 0xABCDEF00 or anything) │
│ │ │
│ ▼ │
│ [RANDOM MEMORY] ← Writing here! │
│ │
│ This could: │
│ • Crash your program (Segmentation Fault) │
│ • Corrupt other data silently │
│ • Work "sometimes" (worst bug!) │
│ │
└─────────────────────────────────────────────────────────┘
✅ SAFE: Initialize Your Pointers!
int *ptr = NULL; // Now ptr = 0, a safe value
// OR
int x = 10;
int *ptr = &x; // Points to valid memory
💾 Dynamic Memory with Pointers
📊 malloc() and free() Basics
Dynamic Memory Allocation
┌─────────────────────────────────────────────────────────┐
│ Step 1: Allocate memory │
│ │
│ int *arr = malloc(5 * sizeof(int)); │
│ │
│ Memory: │
│ ┌─────────────────────────┐ │
│ │ Heap: 5 integers │ │
│ │ [?][?][?][?][?] │ │
│ └──┬──────────────────────┘ │
│ │ │
│ └─ arr stores this address │
│ │
├─────────────────────────────────────────────────────────┤
│ Step 2: Use the memory │
│ │
│ for (int i = 0; i < 5; i++) │
│ arr[i] = i + 1; // or *(arr + i) = i + 1; │
│ │
│ Memory: │
│ ┌─────────────────────────┐ │
│ │ Heap: │ │
│ │ [1][2][3][4][5] │ │
│ └──┬──────────────────────┘ │
│ │ │
│ └─ arr still points here │
│ │
├─────────────────────────────────────────────────────────┤
│ Step 3: Free the memory │
│ │
│ free(arr); │
│ arr = NULL; // Good practice! │
│ │
│ Memory: │
│ ┌─────────────────────────┐ │
│ │ Heap: [FREED] │ │
│ └─────────────────────────┘ │
│ │
│ arr = NULL; // Now safe to check: if (arr != NULL) │
│ │
└─────────────────────────────────────────────────────────┘
dynamic_memory.c
#include <stdio.h>
#include <stdlib.h>
int main() {
int n = 5;
// Allocate memory for n integers
int *arr = (int*)malloc(n * sizeof(int));
// Always check if allocation succeeded!
if (arr == NULL) {
printf("Memory allocation failed!\n");
return 1;
}
// Initialize the array
for (int i = 0; i < n; i++) {
arr[i] = (i + 1) * 10; // 10, 20, 30, 40, 50
}
// Print values
printf("Array values: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
// CRITICAL: Free the allocated memory
free(arr);
arr = NULL; // Prevent dangling pointer
printf("Memory freed successfully!\n");
return 0;
}🎯 Quick Reference Summary
📋 Pointer Cheat Sheet
┌─────────────────────────────────────────────────────────┐
│ POINTER CHEAT SHEET │
├─────────────────────────────────────────────────────────┤
│ │
│ DECLARATION: │
│ ┌─────────────────────────────────────────────────┐ │
│ │ int *ptr; // Pointer to int │ │
│ │ char *cptr; // Pointer to char │ │
│ │ float *fptr; // Pointer to float │ │
│ │ void *vptr; // Generic pointer │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ OPERATORS: │
│ ┌─────────────────────────────────────────────────┐ │
│ │ &variable // Get address of variable │ │
│ │ *pointer // Get value at address │ │
│ │ pointer->field // Access struct field │ │
│ │ (*pointer).field // Same as above │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ COMMON PATTERNS: │
│ ┌─────────────────────────────────────────────────┐ │
│ │ int x = 10; │ │
│ │ int *p = &x; // p points to x │ │
│ │ int y = *p; // y = 10 (dereference) │ │
│ │ *p = 20; // x = 20 (modify through p) │ │
│ │ p++; // Move to next int │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ DYNAMIC MEMORY: │
│ ┌─────────────────────────────────────────────────┐ │
│ │ malloc(n) // Allocate n bytes │ │
│ │ calloc(n, size) // Allocate n items, init 0 │ │
│ │ realloc(ptr, n) // Resize allocation │ │
│ │ free(ptr) // Release memory │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ BEST PRACTICES: │
│ • Always initialize pointers (to NULL or valid addr) │
│ • Check for NULL before dereferencing │
│ • Every malloc() needs a free() │
│ • After free(), set pointer to NULL │
│ • Don't return pointers to local variables │
│ │
└─────────────────────────────────────────────────────────┘
📝 Practice Problems
Level 1: Beginner
- Swap Using Pointers: Write a function that swaps two integers using pointers.
- Array Sum: Calculate the sum of an array using pointer arithmetic instead of array indexing.
- Print Address: Create variables of different types and print their addresses. Notice how they're spaced.
Level 2: Intermediate
- Reverse Array: Reverse an array in place using two pointers (one at start, one at end).
- Dynamic Array: Create a program that allocates an array of size n, fills it with values, then resizes it.
- String Length: Implement strlen() using a pointer (count until '\0').
Level 3: Advanced
- Matrix with Pointers: Allocate a 2D array dynamically using pointer to pointer.
- Linked List Node: Create a simple linked list node structure and traverse it using pointers.
- Function Pointer: Use a function pointer to call different math operations.