// Stack — size must be fixed at compile time
int arr[100];          // OK — 100 is a compile-time constant
// int arr[n];         // VLA (C99) — risky for large n, avoid

// Heap — size decided at runtime
int n;
scanf("%d", &n);
int *arr = malloc(n * sizeof(int));   // allocate exactly what we need
if (!arr) { /* always check! */ exit(1); }
// ... use arr ...
free(arr);
arr = NULL;    // prevent dangling pointer

// realloc(NULL, n) == malloc(n)  — useful for "grow on demand" patterns
int *p = NULL;
p = realloc(p, 100);   // equivalent to malloc(100)

// Shrinking: usually in-place (fast, same address)
buf = realloc(buf, 100);

// Expanding: may copy to new address if not enough contiguous space
char *tmp = realloc(buf, 10000);
if (!tmp) { free(buf); return -1; }
buf = tmp;    // buf may now be a completely different address

int g_init = 42;          // Data segment
int g_uninit;              // BSS (zeroed at startup)
static int s_var = 5;     // Data segment

int main(void) {
    int local = 10;         // Stack
    char *buf = malloc(100); // buf ptr on Stack; 100 bytes on Heap
    const char *s = "Hi";   // "Hi" in read-only Text segment!
    // s[0] = 'h';            // SEGFAULT — writing to read-only text!
    free(buf);
}

// Memory state after many alloc/free cycles:
// [USED 50B][FREE 30B][USED 40B][FREE 30B][USED 60B]
//  Total free = 60B, but you need 60B contiguous → FAILS!

// Internal fragmentation: asked for 100B, allocator gave 128B
// (rounded up for alignment) — 28B are wasted inside the block.

#define GPIO_PORT (*(volatile unsigned int *)0x40021000)

void toggle_led(void) {
    GPIO_PORT = 0x01;   // LED ON
    GPIO_PORT = 0x00;   // LED OFF
    // Without volatile: compiler may delete the first write!
    // volatile forces EVERY read/write to actually happen.
}

// Natural alignments (on x86-64)
// char  → 1-byte   short → 2-byte   int → 4-byte   long → 8-byte

printf("%zu\n", alignof(int));      // 4
printf("%zu\n", alignof(double));   // 8

// Force alignment (GCC/Clang)
struct __attribute__((aligned(64))) CacheLine {
    int data[16];
};
// Used in: DMA buffers, SIMD data, avoid false sharing

// Aligned malloc (C11)
void *buf = aligned_alloc(64, 256);
free(buf);

#define IS_ALIGNED(ptr, n) (((uintptr_t)(ptr) & ((n)-1)) == 0)

#define POOL_COUNT 32
#define BLOCK_SIZE 64

typedef struct {
    uint8_t  data[POOL_COUNT][BLOCK_SIZE];
    uint8_t  used[POOL_COUNT];
} MemPool;

void* pool_alloc(MemPool *pool) {
    for (int i = 0; i < POOL_COUNT; i++) {
        if (!pool->used[i]) {
            pool->used[i] = 1;
            return pool->data[i];
        }
    }
    return NULL;
}

void pool_free(MemPool *pool, void *ptr) {
    int i = ((uint8_t*)ptr - pool->data[0]) / BLOCK_SIZE;
    pool->used[i] = 0;   // O(1)
}
// Benefits: deterministic time, no fragmentation, no system call

int x = 42;
int *p = &x;      // p holds address of x
// p  → the address (e.g. 0x1000)
// *p → the value at that address (42)

*p = 99;         // modifies x through the pointer — now x == 99

// Pointer arithmetic is in units of the POINTED TYPE
int arr[] = {10, 20, 30, 40, 50};
int *q = arr;     // &arr[0]
// If sizeof(int)==4 and q is at address 1000:
// q+1 = 1004 (adds sizeof(int)=4 bytes)
printf("%d\n", *(q + 2));    // 30

// Array decay: array name → pointer to first element in most expressions
void print_size(int arr[]) {
    printf("%zu\n", sizeof(arr)); // sizeof(int*) = 8, NOT array size!
}

int x = 42;
int  *p  = &x;     // p holds address of x
int **pp = &p;     // pp holds address of p — pp → p → x = 42
printf("%d\n", **pp);   // 42

// Real use: function allocates memory and sets caller's pointer
void alloc_array(int **out, size_t n) {
    *out = (int *)malloc(n * sizeof(int));
    if (*out) {
        for (size_t i = 0; i < n; i++) (*out)[i] = 0;
    }
}

int main(void) {
    int *arr = NULL;
    alloc_array(&arr, 10);   // pass address of the pointer
    free(arr);
}

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

// Declaration: return_type (*name)(param_types)
int (*op)(int, int);
op = add;   op(3, 4);  // 7
op = sub;   op(3, 4);  // -1

// Cleaner with typedef:
typedef int (*MathFn)(int, int);
MathFn fn = add;
fn(10, 5);   // 15

// Callback pattern — sort with any comparator
void sort(int *arr, int n, int (*cmp)(int, int)) {
    for (int i = 0; i < n-1; i++)
        for (int j = 0; j < n-i-1; j++)
            if (cmp(arr[j], arr[j+1]) > 0) {
                int tmp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = tmp;
            }
}

void swap(void *a, void *b, size_t size) {
    unsigned char tmp[size];
    memcpy(tmp, a, size);
    memcpy(a, b, size);
    memcpy(b, tmp, size);
}
int x = 10, y = 20;
swap(&x, &y, sizeof(int));   // x=20, y=10 — works with ANY type!

int x = 10, y = 20;

const int *p1 = &x;      // ptr to const int — *p1 immutable, p1 can change
// *p1 = 99;  ERROR
p1 = &y;                 // OK

int *const p2 = &x;      // const ptr to int — *p2 mutable, p2 can't change
*p2 = 99;               // OK
// p2 = &y;  ERROR

const int *const p3 = &x; // const ptr to const int — neither can change

// Mnemonic: "const applies to what's on its LEFT"

// ARRAY OF POINTERS — each element is a pointer
int a = 1, b = 2, c = 3;
int *arr_of_ptrs[3] = {&a, &b, &c};

// POINTER TO ARRAY — one pointer to an entire array
int arr[3] = {1, 2, 3};
int (*ptr_to_arr)[3] = &arr;   // ptr_to_arr + 1 jumps sizeof(int[3]) = 12 bytes

// Real use: pointer to row of 2D array
int matrix[3][4];
int (*row)[4] = matrix;     // row++ advances by 16 bytes (next row)

// argv is a classic array of pointers:
int main(int argc, char *argv[]) { ... }

// Wasteful — 12 bytes
struct Wasteful {
    char c;          // 1 byte + [3 pad]
    int  i;          // 4 bytes
    char d;          // 1 byte + [3 pad]
};                   // total: 12

// Efficient — 8 bytes (reordered largest to smallest)
struct Efficient {
    int  i;          // 4 bytes
    char c;          // 1 byte
    char d;          // 1 byte + [2 pad]
};                   // total: 8

// Rule: order members largest → smallest to minimize padding

// GCC/Clang attribute:
struct __attribute__((packed)) Packet {
    char     type;    // 1 byte (NO padding)
    uint32_t id;     // 4 bytes (may be unaligned!)
    char     flags;   // 1 byte
};                    // sizeof = 6

// MSVC / portable alternative:
#pragma pack(push, 1)
struct Packet2 { char type; int id; char flags; };
#pragma pack(pop)

struct Flags {
    unsigned int enabled  : 1;   // 1 bit  → 0 or 1
    unsigned int mode     : 3;   // 3 bits → 0–7
    unsigned int priority : 4;   // 4 bits → 0–15
    unsigned int reserved : 24;  // padding to fill int
};
// sizeof = 4 (one int, tightly packed)

// Limitations:
// - Bit order depends on compiler + CPU endianness
// - Cannot take address of a bit field (&f.enabled is ILLEGAL)

union Data {
    int   i;          // 4 bytes
    float f;          // 4 bytes
    char  bytes[4];   // 4 bytes
};
// sizeof(union Data) = 4  (size of LARGEST member)
// All members SHARE the same 4 bytes — only ONE is "valid" at a time

// Type punning — inspect float's raw bytes:
union { float f; unsigned char b[4]; } u;
u.f = 3.14f;
printf("%02x %02x %02x %02x\n", u.b[0], u.b[1], u.b[2], u.b[3]);

#define SET_BIT(n, k)    ((n) |=  (1U << (k)))
#define CLEAR_BIT(n, k)  ((n) &= ~(1U << (k)))
#define TOGGLE_BIT(n, k) ((n) ^=  (1U << (k)))
#define TEST_BIT(n, k)   (((n) >> (k)) & 1U)

unsigned int n = 0b1000;
SET_BIT(n, 1);    // n = 0b1010
CLEAR_BIT(n, 3); // n = 0b0010

int count_bits(unsigned int n) {
    int count = 0;
    while (n) {
        n &= (n - 1);   // clears the LOWEST set bit each iteration
        count++;
    }
    return count;
}
// Built-in (GCC): __builtin_popcount(n) — compiled to single instruction

#include <arpa/inet.h>
uint32_t host = 0x12345678;
uint32_t net  = htonl(host);   // Host To Network Long (→ Big Endian)
uint32_t back = ntohl(net);   // Network To Host Long

// Detect endianness at runtime:
int is_little_endian(void) {
    union { uint32_t i; uint8_t c[4]; } test = { .i = 0x01020304 };
    return test.c[0] == 0x04;
}

// USE 1: static inside a function — value persists across calls
void counter(void) {
    static int count = 0;   // initialized ONCE, lives in Data segment
    count++;
    printf("%d ", count);   // 1, 2, 3, ...
}

// USE 2: static at file scope — internal linkage (hidden from other files)
static int secret = 42;   // ONLY visible in this .c file
static void helper(void) { ... }  // private function

// shared.h — declaration (no storage allocated)
extern int global_count;    // "this variable EXISTS somewhere"

// main.c — definition (storage allocated here)
int global_count = 0;

// other.c
#include "shared.h"
void increment(void) { global_count++; }

// Key rule: DECLARE in header (extern), DEFINE in exactly ONE .c file

#define PI       3.14159
#define MAX_SIZE 1024

// ALWAYS parenthesize arguments AND the whole expression
#define SQ(x)     ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))

// WITHOUT outer parens:
#define BAD_SQ(x) x * x
BAD_SQ(1 + 2);       // expands to 1+2*1+2 = 5  ✗ WRONG!

#define SQ(x) ((x) * (x))
int i = 5;
int r = SQ(i++);    // ((i++) * (i++)) — i incremented TWICE! UB!

// FIX: use an inline function instead
inline int sq(int x) { return x * x; }
r = sq(i++);        // i passed by value, incremented ONCE. Safe.

// RIGHT — do-while(0) creates a single statement
#define LOG(msg) do { \
    printf("LOG: %s\n", msg); \
    fflush(stdout); \
} while(0)

// # turns argument into a string literal
#define DBG(var)  printf(#var " = %d\n", var)
int count = 42;
DBG(count);    // prints "count = 42"

// ## glues two tokens together
#define CONCAT(a, b) a##b
int CONCAT(my, var) = 10;  // int myvar = 10;

#include <assert.h>
assert(x > 0);    // crashes with message if false; ZERO cost with -DNDEBUG

// static_assert: evaluated at COMPILE TIME — no runtime cost ever
_Static_assert(sizeof(int) == 4, "int must be 4 bytes");
_Static_assert(CHAR_BIT == 8,    "requires 8-bit bytes");

// Force inlining regardless of compiler judgment:
__attribute__((always_inline)) inline void must_inline(void) { ... }

// Prevent inlining (for profiling / call shows in stack trace):
__attribute__((noinline)) void never_inline(void) { ... }

// static inline — most common pattern for header utilities
static inline int clamp(int v, int lo, int hi) {
    return v < lo ? lo : (v > hi ? hi : v);
}

// 1. Use after free
int *p = malloc(sizeof(int));
free(p);
*p = 100;   // UNDEFINED BEHAVIOR

// 2. Dangling pointer to stack variable
int *get_local(void) {
    int x = 42;
    return &x;   // WRONG — x gone after return
}

// 3. Out-of-bounds access
int arr[5];
arr[5] = 99;   // UB — one past end

// 4. Signed integer overflow
int x = INT_MAX;
x++;            // UB — optimizer may assume this never happens!

// 5. Sequence point violation
int r = i++ + i++;  // UB — modification order unspecified

int arr[5] = {1, 2, 3, 4, 5};
int *p = arr;

sizeof(arr);           // 20 — compiler knows full array size (5 × 4)
sizeof(p);             // 8  — sizeof pointer

// Reassignment:
p = some_other_array;  // OK — pointers are reassignable
// arr = other;        // ERROR — array name is NOT an lvalue

// sizeof loss in functions:
void fn(int arr[]) {
    sizeof(arr);   // 8 — decays to pointer! Size is LOST.
}
// Always pass array length separately: fn(int *arr, size_t n)

char str[] = "Hello";
// str = ['H']['e']['l']['l']['o']['\0']  — 6 bytes including null!

strlen(str);    // 5 — does NOT include '\0'
sizeof(str);    // 6 — includes '\0'
sizeof(p);      // 8 — sizeof pointer, NOT string length!

// String literal is READ-ONLY:
char *lit = "Hello";
lit[0] = 'J';   // SEGFAULT — read-only text segment

// Writable copy:
char buf[] = "Hello";   // copies to stack — writable

char dest[5];

// UNSAFE: strcpy — no bounds checking
strcpy(dest, "Hello World!");   // BUFFER OVERFLOW!

// SAFER: strncpy — copies at most n bytes, but may NOT null-terminate!
strncpy(dest, src, sizeof(dest) - 1);
dest[sizeof(dest) - 1] = '\0';   // always guarantee null-termination

// DANGEROUS: gets() — NEVER use! Removed in C11.
// SAFE: fgets(buf, sizeof(buf), stdin);

// strcmp — compare strings (NOT ==)
if (strcmp(a, b) == 0) { /* strings equal */ }