C Pointers — Complete Guide

#include <stdio.h>

int main() {
    int  x = 42;     // regular int variable
    int *p = &x;     // p is a pointer — stores the address of x

    printf("Value of x:       %d\n",  x);   // 42
    printf("Address of x:     %p\n", &x);   // 0x7fff...  (changes every run)
    printf("Value of p:       %p\n",  p);   // same address as &x
    printf("Value at *p:      %d\n", *p);   // 42  — follows the address

    return 0;
}

#include <stdio.h>

int main() {
    int  x = 42;
    int *p;          // DECLARATION — * means "p is a pointer to int"
    p = &x;          // & means "address of x"

    // Three different things from same pointer:
    printf("x    = %d\n",  x);    // 42  — value directly
    printf("*p   = %d\n", *p);    // 42  — EXPRESSION: follow address, read value
    printf("p    = %p\n",  p);    // 0x... — the address NUMBER itself
    printf("&x   = %p\n", &x);    // same address — & gives address of x

    // x and *p are literally the same memory box!
    *p = 100;   // EXPRESSION: write 100 through the pointer
    printf("After *p=100: x = %d\n", x);  // x is 100 too!

    return 0;
}

#include <stdio.h>

int main() {
    int x = 42;
    int *p = &x;

    printf("Before: x = %d\n", x);    // 42

    *p = 30;   // write 30 into x through pointer
    printf("After *p=30: x = %d\n", x); // 30

    (*p)++;    // increment through pointer (parentheses important!)
    printf("After (*p)++: x = %d\n", x); // 31

    // Multiple pointers to same variable
    int *q = &x;   // q also points to x
    *q = 999;
    printf("After *q=999: x=%d *p=%d\n", x, *p); // both 999

    return 0;
}

#include <stdio.h>

// Function takes POINTER — can modify original variable
void doubleIt(int *num) {
    *num = *num * 2;   // modify the original through pointer
}

// Function takes VALUE — only gets a copy, cannot change original
void tryDouble(int num) {
    num = num * 2;   // changes only the LOCAL copy
}

int main() {
    int x = 10;

    tryDouble(x);
    printf("After tryDouble: x = %d\n", x);   // still 10

    doubleIt(&x);
    printf("After doubleIt:  x = %d\n", x);   // 20!

    return 0;
}

#include <stdio.h>

int main() {
    int  arr[3] = {10, 20, 30};
    int *p = arr;   // arr is already the address of arr[0]

    // Two ways — identical output
    printf("Array notation:   %d %d %d\n", arr[0],  arr[1],  arr[2]);
    printf("Pointer notation: %d %d %d\n", *(p+0), *(p+1), *(p+2));

    // Walking through array with pointer
    printf("Walking: ");
    for (int i = 0; i < 3; i++) {
        printf("%d ", *p);
        p++;   // advance pointer to next element
    }
    printf("\n");

    // arr[i] IS *(arr+i) — the compiler generates same code
    printf("arr[2] = %d  |  *(arr+2) = %d\n", arr[2], *(arr+2));

    return 0;
}

// ❌ WRONG — wild pointer — undefined behaviour
int *p;        // p contains garbage — points anywhere
*p = 10;      // writing to a random address — CRASH or corruption!

// ✅ CORRECT — always initialize
int  x  = 0;
int *p  = &x;  // p points to x — safe to use
// OR if you don't have a variable yet:
int *p2 = NULL; // NULL marks it as "not pointing to anything yet"

// ❌ WRONG — null dereference — always crashes
int *p = NULL;
*p = 10;    // CRASH — address 0 is protected by the OS

// ✅ CORRECT — check before using
int *p = NULL;
if (p != NULL) {
    *p = 10;  // safe — only runs if p actually points somewhere
}

#include <stdlib.h>

// ❌ WRONG — dangling pointer
int *p = malloc(sizeof(int));
free(p);       // memory returned to OS
*p = 99;       // UNDEFINED BEHAVIOUR — p is now "dangling"

// ✅ CORRECT — null the pointer immediately after free
int *p = malloc(sizeof(int));
free(p);
p = NULL;      // any accidental *p use now crashes visibly — better than silent corruption

int arr[3] = {1, 2, 3};
int *p = arr + 3;  // valid: one-past-the-end address is fine to HOLD

// ❌ WRONG — dereferencing one-past-the-end
*p = 5;   // UNDEFINED BEHAVIOUR — that memory is not part of arr

// ✅ Use it only as a sentinel to detect end-of-array:
int *end = arr + 3;
for (int *q = arr; q < end; q++) {
    printf("%d ", *q);  // safe — q never reaches end
}

int  x  = 42;
int *p  = &x;   // DECLARATION — * means "p is a pointer to int"
                //              NOT "dereference" here

*p = 10;       // EXPRESSION — * means "dereference: follow address, write 10"

// Ask yourself every time:
// Am I DECLARING a new pointer variable? → * = type label
// Am I USING an existing pointer?        → * = dereference operator