#include <stdio.h>

int main(void) {
    int x = 42;
    int *p = &x;   // p now holds the ADDRESS of x, not x's value

    printf("value of x:          %d\n", x);
    printf("address of x:        %p\n", (void *)&x);
    printf("value stored in p:   %p\n", (void *)p);      // same as &x
    printf("value p points to:   %d\n", *p);              // dereference -- gives 42

    *p = 100;   // modifies x THROUGH the pointer
    printf("x is now:            %d\n", x);               // 100 -- x itself changed

    return 0;
}

#include <stdio.h>
#include <stddef.h>   // for NULL

int main(void) {
    int *p1;             // UNINITIALIZED -- holds garbage, NOT NULL, dangerous to dereference
    int *p2 = NULL;       // explicitly points to nothing -- safe, checkable state

    if (p2 == NULL) {
        printf("p2 points to nothing\n");
    }

    int x = 5;
    p1 = &x;   // now safely initialized

    // Declaration syntax quirk: the '*' binds to the VARIABLE, not the type,
    // despite how it's often read:
    int *a, b;    // 'a' is "int *", but 'b' is just a plain "int", NOT "int *"!
    int *c, *d;   // this is how you declare TWO pointers on one line correctly

    (void)a; (void)b; (void)c; (void)d;   // silence unused-variable warnings for this example
    printf("%d\n", *p1);
    return 0;
}

#include <stdio.h>

int main(void) {
    int numbers[5] = {10, 20, 30, 40, 50};
    int *p = numbers;   // points to numbers[0]; an array name decays to a pointer to its first element

    printf("%d\n", *p);         // 10
    printf("%d\n", *(p + 1));   // 20 -- moved by 1 int (4 bytes on most platforms), NOT 1 byte
    printf("%d\n", *(p + 2));   // 30

    p++;                        // now points to numbers[1]
    printf("%d\n", *p);         // 20

    int *start = numbers;
    int *end = numbers + 5;     // one PAST the last element -- valid to compute, NOT valid to dereference
    printf("elements between start and end: %ld\n", (long)(end - start));   // pointer subtraction: 5

    return 0;
}

#include <stdio.h>

int main(void) {
    int numbers[5] = {10, 20, 30, 40, 50};
    int *p = numbers;   // valid WITHOUT '&' -- numbers already decays to &numbers[0]

    // These four are all completely equivalent ways to get the 3rd element:
    printf("%d\n", numbers[2]);
    printf("%d\n", *(numbers + 2));
    printf("%d\n", p[2]);
    printf("%d\n", *(p + 2));

    // But 'numbers' and 'p' are NOT the same kind of thing, despite behaving
    // similarly here -- 'numbers' is an array (its size is baked into its
    // type), 'p' is just a pointer (no size information at all):
    printf("%zu\n", sizeof(numbers));   // 20 -- the whole array's size
    printf("%zu\n", sizeof(p));         // 8 (or 4) -- just a pointer's size

    return 0;
}

#include <stdio.h>

int main(void) {
    int numbers[5] = {10, 20, 30, 40, 50};

    printf("%d\n", numbers[2]);       // 30, the normal way to write it
    printf("%d\n", *(numbers + 2));   // 30, exactly equivalent
    printf("%d\n", *(2 + numbers));   // 30, addition is commutative!
    printf("%d\n", 2[numbers]);       // 30, ALSO legal C, because array indexing
                                        // literally IS pointer arithmetic under
                                        // the hood -- 2[numbers] means *(2 + numbers)

    return 0;
}

#include <stdio.h>

void processArray(int *arr) {
    // arr is a POINTER here, not an array -- this is ALWAYS wrong inside
    // a function that received an array as a parameter:
    printf("inside function, sizeof(arr) = %zu\n", sizeof(arr));   // 8 (pointer size)
    // int wrongCount = sizeof(arr) / sizeof(arr[0]);  // silently WRONG -- computes 2, not 5!
}

int main(void) {
    int numbers[5] = {1, 2, 3, 4, 5};

    printf("in main, sizeof(numbers) = %zu\n", sizeof(numbers));   // 20 (whole array)
    int correctCount = sizeof(numbers) / sizeof(numbers[0]);       // 5 -- correct HERE, in main
    printf("correct count: %d\n", correctCount);

    processArray(numbers);   // numbers decays to a pointer the moment it's passed
    return 0;
}

#include <stdio.h>

int main(void) {
    int x = 42;
    int *p = &x;      // p points to x
    int **pp = &p;     // pp points to p

    printf("%d\n", x);      // 42, directly
    printf("%d\n", *p);     // 42, one level of dereference
    printf("%d\n", **pp);   // 42, two levels of dereference

    **pp = 100;    // modifies x, going through BOTH levels of indirection
    printf("%d\n", x);   // 100

    int y = 7;
    *pp = &y;      // changes what p itself points to, WITHOUT touching pp
    printf("%d\n", *p);   // 7 -- p now points to y instead of x

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int x = 42;
    void *generic = &x;   // can point to ANY type

    // *generic;   // COMPILE ERROR -- can't dereference void*, size unknown
    int *typed = (int *)generic;   // must cast back to a concrete type first
    printf("%d\n", *typed);         // 42

    // This is exactly why malloc returns void* -- it doesn't know or care
    // what TYPE of data you're going to store in the memory it allocates:
    void *raw = malloc(sizeof(int) * 5);
    int *numbers = (int *)raw;      // cast (optional in C, required in C++) to use it as ints
    numbers[0] = 100;
    printf("%d\n", numbers[0]);
    free(raw);

    return 0;
}

#include <stdio.h>

int main(void) {
    int x = 10, y = 20;

    int *p1 = &x;                  // plain pointer: can change BOTH the pointer and the value
    *p1 = 11;                       // OK
    p1 = &y;                        // OK

    const int *p2 = &x;            // pointer to const int: value is read-only, pointer can move
    // *p2 = 99;                    // COMPILE ERROR -- can't modify the pointed-to value
    p2 = &y;                        // OK -- the pointer itself isn't const

    int *const p3 = &x;            // const pointer: value can change, pointer CANNOT move
    *p3 = 99;                       // OK
    // p3 = &y;                     // COMPILE ERROR -- p3 itself is const

    const int *const p4 = &x;      // const pointer to const int: NEITHER can change
    // *p4 = 99;                    // COMPILE ERROR
    // p4 = &y;                     // COMPILE ERROR

    printf("%d %d %d %d\n", *p1, *p2, *p3, *p4);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    // malloc: allocates raw, UNINITIALIZED memory of the given byte size
    int *a = malloc(5 * sizeof(int));
    if (a == NULL) {   // ALWAYS check -- malloc can fail, especially for large requests
        fprintf(stderr, "allocation failed\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) a[i] = i * 10;   // must initialize yourself -- contents were garbage

    // calloc: allocates memory for 'count' elements of 'size' bytes each,
    // and ZERO-INITIALIZES it -- unlike malloc
    int *b = calloc(5, sizeof(int));
    if (b == NULL) { fprintf(stderr, "allocation failed\n"); free(a); return 1; }
    printf("calloc'd memory is pre-zeroed: %d\n", b[0]);   // 0, guaranteed

    // realloc: resizes a previous allocation, preserving existing content
    // up to the smaller of the old/new sizes -- may MOVE the memory elsewhere
    int *c = realloc(a, 10 * sizeof(int));   // grow 'a' from 5 to 10 ints
    if (c == NULL) {
        // realloc failure: the ORIGINAL pointer 'a' is still valid and must
        // still be freed -- this is why you never do "a = realloc(a, ...)" directly
        fprintf(stderr, "realloc failed\n");
        free(a);
        free(b);
        return 1;
    }
    a = c;   // safe now: c is the new (possibly moved) block
    printf("%d\n", a[0]);   // 0 -- original content preserved after the resize

    free(a);
    free(b);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

void leaky(void) {
    int *data = malloc(100 * sizeof(int));
    if (data == NULL) return;

    data[0] = 42;
    // MISSING free(data) -- this memory is now unreachable (the only
    // pointer to it, 'data', is a local variable about to go out of
    // scope) but the OS still considers it allocated. Call this
    // function a million times and you'll exhaust available memory.
}   // 'data' the POINTER is destroyed here; the MEMORY it pointed to is not

void correct(void) {
    int *data = malloc(100 * sizeof(int));
    if (data == NULL) return;

    data[0] = 42;
    free(data);   // memory returned to the system -- no leak
}

int main(void) {
    leaky();
    correct();
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 42;

    free(p);   // the memory is returned to the system...
    // p still holds the SAME address it did before -- it is now a
    // DANGLING pointer, even though it looks unchanged

    // printf("%d\n", *p);   // USE-AFTER-FREE: undefined behavior. Might
                               // print 42 anyway (if the memory hasn't
                               // been reused yet), might print garbage,
                               // might crash -- there's no way to know,
                               // and that unpredictability IS the danger

    p = NULL;   // best practice: null out a pointer immediately after
                 // freeing it, so any accidental future use fails LOUDLY
                 // (a crash on *p) instead of silently corrupting data

    if (p != NULL) {
        printf("%d\n", *p);   // never reached -- p is NULL, safely checkable
    }

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 42;

    free(p);
    // free(p);   // DOUBLE FREE: undefined behavior. The memory allocator's
                    // internal bookkeeping is now corrupted -- this can crash
                    // immediately, corrupt unrelated memory, or (in the worst
                    // real-world cases) be exploitable by an attacker who can
                    // influence what gets allocated next

    p = NULL;   // exactly the same fix as section 12 -- once nulled, a
                 // second "free(p)" becomes free(NULL), which is explicitly
                 // defined by the standard to safely do nothing at all
    free(p);     // SAFE -- freeing NULL is a guaranteed no-op

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int *findValue(int *arr, int len, int target) {
    for (int i = 0; i < len; i++) {
        if (arr[i] == target) {
            return &arr[i];
        }
    }
    return NULL;   // explicitly signal "not found" -- the standard C idiom
}

int main(void) {
    int numbers[5] = {10, 20, 30, 40, 50};

    int *found = findValue(numbers, 5, 30);
    if (found != NULL) {   // ALWAYS check before dereferencing a pointer that
                             // might legitimately be NULL, e.g. from malloc or
                             // a "search" function like this one
        printf("found: %d\n", *found);
    }

    int *notFound = findValue(numbers, 5, 999);
    if (notFound != NULL) {
        printf("found: %d\n", *notFound);
    } else {
        printf("not found\n");   // this branch runs -- and safely so
    }
    // printf("%d\n", *notFound);   // would crash: dereferencing NULL

    return 0;
}

#include <stdio.h>

int main(void) {
    int *wild;   // UNINITIALIZED -- holds a random, garbage address, NOT NULL

    // *wild = 42;   // undefined behavior: might crash immediately, might
                       // silently corrupt some unrelated variable's memory,
                       // might even appear to "work" -- there's no way to
                       // know in advance, which is exactly what makes wild
                       // pointers more insidious than a NULL pointer (which
                       // at least crashes predictably and immediately)

    int *safe = NULL;   // ALWAYS initialize pointers, even if just to NULL,
                          // so an accidental early dereference fails loudly
                          // and predictably instead of corrupting memory

    if (safe != NULL) {
        printf("%d\n", *safe);
    } else {
        printf("safe was never assigned a real address\n");
    }

    return 0;
}

#include <stdio.h>
#include <string.h>

int main(void) {
    char *literal = "Hello";   // points to a STRING LITERAL -- typically stored
                                 // in READ-ONLY memory by the compiler/OS

    // literal[0] = 'h';   // undefined behavior on most platforms -- modifying
                             // a string literal often crashes (though the C
                             // standard doesn't strictly forbid it, real
                             // compilers/OSes commonly place literals in
                             // write-protected memory)

    char array[] = "Hello";   // COPIES the characters into a local, WRITABLE array
    array[0] = 'h';            // perfectly fine -- this is real, mutable memory
    printf("%s\n", array);     // hello

    // Best practice: use 'const char *' for a pointer to a string literal,
    // so the compiler catches accidental modification attempts:
    const char *safeLiteral = "World";
    // safeLiteral[0] = 'w';   // COMPILE ERROR -- caught at compile time, not runtime

    printf("%zu\n", strlen(safeLiteral));   // 5 -- strlen doesn't count the '\0' terminator
    printf("%zu\n", sizeof("World"));        // 6 -- sizeof DOES count the '\0' terminator

    return 0;
}

#include <stdio.h>

int main(void) {
    // An array of 3 pointers, each pointing to a different string literal
    const char *fruits[3] = {"apple", "banana", "cherry"};

    for (int i = 0; i < 3; i++) {
        printf("%s\n", fruits[i]);   // fruits[i] is a char*, printed with %s
    }

    // This is EXACTLY the shape of argv in "int main(int argc, char *argv[])":
    // an array of char* pointers, each one pointing to one argument string.
    // argv[0] is the program name, argv[1] the first real argument, etc.

    printf("address of fruits[0]: %p\n", (void *)&fruits[0]);
    printf("address fruits[0] points to: %p\n", (void *)fruits[0]);
    // these two addresses are DIFFERENT -- fruits[0] itself lives in the
    // array; the STRING "apple" it points to lives somewhere else entirely
    // (typically the same read-only literal storage from section 16)

    return 0;
}

#include <stdio.h>

int main(void) {
    int a = 1, b = 2, c = 3;

    int *arrayOfPointers[3] = {&a, &b, &c};   // an ARRAY containing 3 separate int*
    printf("%d %d %d\n", *arrayOfPointers[0], *arrayOfPointers[1], *arrayOfPointers[2]);

    int numbers[3] = {10, 20, 30};
    int (*pointerToArray)[3] = &numbers;      // a SINGLE pointer to one whole array of 3 ints
    printf("%d %d %d\n", (*pointerToArray)[0], (*pointerToArray)[1], (*pointerToArray)[2]);

    printf("%zu\n", sizeof(arrayOfPointers));   // 3 pointers' worth of space (e.g. 24)
    printf("%zu\n", sizeof(pointerToArray));    // ONE pointer's worth of space (e.g. 8) --
                                                   // even though it "points to" 3 ints' worth
                                                   // of data elsewhere

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

// WRONG for this purpose: reassigning the LOCAL COPY 'p' inside the
// function has no effect on the caller's pointer at all.
void allocateWrong(int *p) {
    p = malloc(sizeof(int));   // only changes the local copy of the pointer
    *p = 42;
}

// RIGHT: takes a pointer TO the caller's pointer, so it can modify what
// the CALLER's own pointer variable points to.
void allocateRight(int **p) {
    *p = malloc(sizeof(int));   // dereference once to reach the caller's actual pointer
    **p = 42;                    // dereference again to reach the allocated int
}

int main(void) {
    int *a = NULL;
    allocateWrong(a);
    printf("%p\n", (void *)a);   // still NULL -- allocateWrong never actually changed it

    int *b = NULL;
    allocateRight(&b);           // pass the ADDRESS of the pointer itself
    printf("%d\n", *b);          // 42 -- b now correctly points to the allocated memory
    free(b);

    return 0;
}

#include <stdio.h>

int add(int a, int b) { return a + b; }

int main(void) {
    int (*operation)(int, int) = add;   // 'operation' points to the FUNCTION 'add'
    printf("%d\n", operation(3, 4));     // 7 -- called indirectly through the pointer

    return 0;
}

#include <stdio.h>

typedef struct {
    int x, y;
} Point;

int main(void) {
    Point p = {3, 4};
    Point *ptr = &p;

    printf("%d\n", ptr->x);      // shorthand for (*ptr).x
    ptr->x = 100;                 // modifies the original p through the pointer
    printf("%d\n", p.x);          // 100

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int rows = 3, cols = 4;

    // Allocate an array of 'rows' int* pointers...
    int **grid = malloc(rows * sizeof(int *));
    if (!grid) return 1;

    // ...then allocate each ROW separately.
    for (int i = 0; i < rows; i++) {
        grid[i] = malloc(cols * sizeof(int));
        if (!grid[i]) return 1;   // (a real program would also free earlier rows here)
    }

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            grid[i][j] = i * cols + j;   // grid[i][j] works exactly like a real 2D array
        }
    }

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", grid[i][j]);
        }
        printf("\n");
    }

    // Must free in the OPPOSITE order: every row first, THEN the array of row pointers
    for (int i = 0; i < rows; i++) {
        free(grid[i]);
    }
    free(grid);

    return 0;
}

#include <stdio.h>

int main(void) {
    int x = 0x12345678;

    // Reading the same memory through an INCOMPATIBLE pointer type
    // violates strict aliasing -- undefined behavior, even though it
    // often appears to "work" on common compilers/platforms:
    // float *asFloat = (float *)&x;
    // printf("%f\n", *asFloat);   // technically UB, avoid this pattern

    // The safe, portable way to reinterpret bytes between types is memcpy,
    // exactly as covered in the structs guide's protocol-parsing section:
    float asFloatSafe;
    // (Only meaningful if sizeof(int) == sizeof(float), true on most platforms)
    if (sizeof(int) == sizeof(float)) {
        __builtin_memcpy(&asFloatSafe, &x, sizeof(x));   // or plain memcpy() with <string.h>
        printf("%f\n", asFloatSafe);
    }

    // Casting between pointer-to-COMPATIBLE-type is fine and common,
    // e.g. void* to a concrete type (section 8), or up/down a type
    // hierarchy of struct types intentionally designed for it.

    return 0;
}

#include <stdio.h>

int main(void) {
    int x = 42;

    int *p1 = &x;                    // p1 is a pointer to int
    int **p2 = &p1;                   // p2 is a pointer to (a pointer to int)
    int a1[5];                        // a1 is an array of 5 ints
    int *a2[5];                       // a2 is an array of 5 (pointers to int)
    int (*p3)[5];                     // p3 is a pointer to (an array of 5 ints)
    int (*fp)(int, int);              // fp is a pointer to (a function taking (int,int), returning int)
    int *(*fp2)(int);                 // fp2 is a pointer to (a function taking int, returning int*)

    (void)p2; (void)a1; (void)a2; (void)p3; (void)fp; (void)fp2;

    printf("Reading rule demo compiled successfully.\n");
    printf("%d\n", **p2 == x);   // 1 -- confirms p2 really does reach x through two levels
    return 0;
}