Double Pointers in C

A double pointer (or pointer to a pointer) is a pointer that stores the address of another pointer. Instead of directly pointing to a variable, it first points to a pointer, which in turn points to the actual variable.

Imagine a house address (memory location of a variable) written on a note (pointer), and someone is holding that note. Now, if another person writes the location of that note on a separate register (double pointer), this is similar to how a double pointer works in C.

Example 1:

#include <stdio.h>

int main() {
    int num = 10;
    int *ptr = &num;    // Pointer to num
    int **dptr = &ptr;  // Double pointer storing address of ptr

    // Printing values and addresses
    printf("Value of num: %d\n", num);
    printf("Address of num: %p\n", &num);
    
    printf("Value at ptr (num's value): %d\n", *ptr);
    printf("Address of ptr: %p\n", &ptr);
    
    printf("Value at dptr (ptr's value, which is num's address): %p\n", *dptr);
    printf("Value at **dptr (num's value): %d\n", **dptr);

    return 0;
}

Output:

Value of num: 10
Address of num: 0x7ffc8a1b32c4
Value at ptr (num's value): 10
Address of ptr: 0x7ffc8a1b32c8
Value at dptr (ptr's value, which is num's address): 0x7ffc8a1b32c4
Value at **dptr (num's value): 10

Explanation:

The address increased by 4 bytes because ptr is a pointer to an int, and in most systems, an int occupies 4 bytes in memory (on a 32-bit or 64-bit system where sizeof(int) = 4).

Breakdown of Address Changes:

Let's assume:
num is stored at 0x7ffc8a1b32c4
ptr is stored at 0x7ffc8a1b32c8

Why does ptr’s address come right after num?
1. num is an integer and occupies 4 bytes.
2. Since ptr is declared immediately after num, it gets stored right after the 4-byte space allocated for num.
3. Thus, the address of ptr is 0x7ffc8a1b32c8 (0x7ffc8a1b32c4 + 4).

Will this always be 4 bytes?
Not necessarily. The address change depends on:
sizeof(int) → If an int is 2 bytes (older systems) or 8 bytes (some 64-bit systems), the gap will be different.
Memory alignment → The compiler may add extra space (padding) for efficiency.
Variable placement → If declared differently, variables may not be next to each other.