Pointers Basics in C

🟡 Intermediate

📖 Definition

A pointer is a variable that stores the memory address of another variable as its value. Pointers provide direct access to computer memory, enabling efficient data manipulation and dynamic memory management.

🌐 Multilingual Explanation

English

A pointer stores a memory address. The address-of operator & retrieves the memory address of a variable. The dereference operator * accesses or modifies the value stored at the memory address held by the pointer. Pointers initialized to NULL explicitly signal that they point to no valid memory location.

Hindi

Pointer ek aisa variable hai jo kisi doosre variable ka memory address store karta hai. Address-of operator & kisi variable ka memory address nikalta hai. Dereference operator * us address par rakhi value ko read ya modify karta hai. Pointer ko NULL par set karne se woh safe rehta hai.

Marathi

Pointer mhanje dusrya variable cha memory address sathavanya saathi vaparala janara variable. & operator variable cha address deto. * operator (dereference) tya address varil value vachato kiva badalto. Invalid access talnyasathi pointer NULL thevla jato.

Hinglish

Pointer memory address hold karta hai. Address nikalne ke liye &var use hota hai, aur pointer ke andar ki value ko update/read karne ke liye dereference operator *ptr use hota hai. Uninitialized pointer (Wild Pointer) dereference karne par Segmentation Fault crash ho jata hai. %p with (void*)ptr format specifier use karo.

🤔 Why Do We Use Them?

Pointers are C’s most powerful feature. They allow functions to modify variables in caller scopes (pass-by-address), enable dynamic memory allocation on the Heap, allow fast passing of large structures without copying, and build dynamic data structures like linked lists and trees.

🧠 Simple Explanation

Think of variables and memory like houses on a street:

  • Variable int score = 95 is a house containing value 95.
  • House Address &score is the street house number (e.g. 0x7ffd5f12).
  • Pointer int *pScore = &score is a piece of paper holding the house address written on it.
  • Dereferencing *pScore means walking to house 0x7ffd5f12 and looking inside or changing the furniture inside.

📝 Syntax & Key Operators

1. Address-of Operator (&)

Returns the memory address of a variable:

int age = 25;
printf("Address of age: %p\n", (void*)&age);

2. Pointer Declaration & Initialization

The asterisk * in a type declaration specifies a pointer variable:

int *pAge = &age; // pAge holds the memory address of 'age'

3. Dereference / Indirection Operator (*)

Accesses or modifies the value stored at the address held by the pointer:

*pAge = 26; // Modifies the value of 'age' directly to 26!

4. NULL Pointer

Safety initialization indicating pointer points to nothing:

int *pSafe = NULL;

💡 Practical Example

Here is a practical program demonstrating pointer syntax, memory address inspection, in-place variable swapping, and NULL safety checks:

#include <stdio.h>

// Function modifying caller variables using pointers
void swap(int *a, int *b) {
    int temp = *a; // Store value at address 'a'
    *a = *b;       // Overwrite value at address 'a' with value at address 'b'
    *b = temp;     // Overwrite value at address 'b' with temp
}

int main(void) {
    int accountA = 1000;
    int accountB = 5000;

    // 1. Pointer Declarations
    int *pAccountA = &accountA;

    printf("--- POINTER MEMORY INSPECTION ---\n");
    printf("Value of accountA             : $%d\n", accountA);
    printf("Memory Address of accountA (&): %p\n", (void*)&accountA);
    printf("Value stored in pAccountA     : %p\n", (void*)pAccountA);
    printf("Value dereferenced (*pAccountA): $%d\n\n", *pAccountA);

    // 2. Modifying value via dereferencing
    *pAccountA = 1500; // Directly updates 'accountA'
    printf("Updated accountA via pointer   : $%d\n\n", accountA);

    // 3. In-Place Swapping using Function Pointers
    printf("--- SWAPPING VALUES VIA POINTERS ---\n");
    printf("Before Swap: accountA = $%d | accountB = $%d\n", accountA, accountB);
    swap(&accountA, &accountB); // Pass memory addresses of accountA and accountB
    printf("After Swap : accountA = $%d | accountB = $%d\n\n", accountA, accountB);

    // 4. NULL Pointer Safety Check
    int *pUnassigned = NULL;
    if (pUnassigned != NULL) {
        printf("Value: %d\n", *pUnassigned);
    } else {
        printf("Safety Guard: pUnassigned is NULL! Dereference prevented.\n");
    }

    return 0;
}

🔍 Code Breakdown

  • int *pAccountA = &accountA;: Creates a pointer variable pAccountA of type int* and stores the memory address of accountA inside it.
  • (void*)pAccountA: ISO C standard requires casting pointers to (void*) when printing addresses using the %p format specifier.
  • swap(&accountA, &accountB): Passes the memory addresses of accountA and accountB to swap(). Inside swap(), dereferencing *a and *b swaps the actual caller variables in main().

👀 Output

--- POINTER MEMORY INSPECTION ---
Value of accountA             : $1000
Memory Address of accountA (&): 0x7ffdb120c4ac (Address varies by run/system)
Value stored in pAccountA     : 0x7ffdb120c4ac
Value dereferenced (*pAccountA): $1000

Updated accountA via pointer   : $1500

--- SWAPPING VALUES VIA POINTERS ---
Before Swap: accountA = $1500 | accountB = $5000
After Swap : accountA = $5000 | accountB = $1500

Safety Guard: pUnassigned is NULL! Dereference prevented.

⚠️ Common Mistakes

  • Wild Pointers (Uninitialized Pointers): Declaring a pointer without initializing it (int *p; *p = 10;). p contains random garbage memory addresses. Dereferencing it writes data to random CPU memory, causing unpredictable crashes (Segmentation Faults).
  • Dereferencing NULL Pointers: Attempting to read or write *ptr when ptr == NULL causes an immediate OS crash. Always perform if (ptr != NULL) checks before dereferencing!
  • Confusing Pointer Declaration with Dereferencing:
    • In declaration: int *p; (* specifies p is a pointer).
    • In expression: *p = 50; (* means dereference/access value at address).

🛡️ Safety / Important Notes

  • Always initialize pointers upon declaration: either point to a valid variable address (int *p = &var;) or set to NULL (int *p = NULL;).
  • Use format specifier %p with explicit (void*) cast when printing pointer addresses in printf.

🌍 Real-World Usage

Pointers power C hardware registers, memory-mapped I/O in microcontrollers, dynamic heap allocation (malloc), pass-by-address function mutations, and operating system data structures.

🧪 Try It Yourself

  1. Declare a variable int score = 80.
  2. Create a pointer pScore pointing to score.
  3. Add 15 points to score by dereferencing pScore (*pScore += 15).
  4. Print score.

🎯 Mini Challenge

Write a function void doubleValue(int *val) that doubles the value of an integer variable passed to it by pointer. Test it in main() with a variable int number = 45.

🔗 Related Topics

🧭 Navigation

← C Home ← Previous: Arrays Next: Advanced Pointers →