C

Memory Management

• Every malloc needs a free — track ownership, free once only
• free(ptr); ptr = NULL; — prevents use-after-free
• Check malloc return — can return NULL on failure
• calloc zeros memory — malloc leaves garbage
• Memory leaks on early return — ensure cleanup path for all exits

Buffer Overflows

• strcpy doesn't check bounds — use strncpy or snprintf
• gets is never safe — removed in C11, use fgets
• sprintf can overflow — use snprintf with buffer size
• Array index not checked — manual bounds checking required
• Stack buffer overflow corrupts return address — security vulnerability

Strings

• Strings need null terminator \0 — strncpy may not add it if truncated
• strlen doesn't count null — allocate strlen(s) + 1
• String literals are immutable — modifying causes undefined behavior
• sizeof(str) vs strlen(str) — sizeof includes null, strlen doesn't
• char str[] copies, char *str points to literal — different behavior

Pointers

• Uninitialized pointer is garbage — always initialize or set to NULL
• Dereferencing NULL is undefined — check before use
• Pointer arithmetic in bytes vs elements — p + 1 advances by sizeof(*p)
• Array decays to pointer — sizeof(arr) in function gives pointer size
• Returning pointer to local — stack frame gone, dangling pointer

Undefined Behavior

• Signed integer overflow is undefined — not wrap-around like unsigned
• Uninitialized variable read — garbage value, unpredictable
• Modifying variable twice between sequence points — i++ + i++ undefined
• Null pointer dereference — crash or worse
• Shift by negative or >= width — undefined

Integer Gotchas

• Integer promotion in expressions — small types promote to int
• Unsigned vs signed comparison — signed converted to unsigned, negative becomes large
• sizeof returns size_t (unsigned) — subtraction can wrap
• Division truncates toward zero — -7 / 2 is -3, not -4

Arrays

• Array size must be constant (before C99 VLAs) — use malloc for dynamic
• VLAs can stack overflow — no size limit check, avoid for large/variable sizes
• arr[i] is *(arr + i) — pointer arithmetic under the hood
• Multidimensional arrays contiguous — arr[i][j] is arr[i * cols + j] equivalent
• Can't return array — return pointer to static or allocated memory

Preprocessor

• Macro arguments evaluated multiple times — MAX(i++, j) increments i multiple times
• Wrap macro body in do { ... } while(0) — for statement-like macros
• Wrap arguments in parentheses — #define SQ(x) ((x) * (x))
• #include order matters — headers may depend on prior includes

Common Mistakes

• = vs == in conditions — if (x = 5) assigns, always true
• Missing break in switch — falls through to next case
• sizeof(ptr) gives pointer size — not array or allocated size
• Forgetting to flush stdout — printf without \n may not appear
• fopen returns NULL on failure — always check before using file pointer