C · Intermediate
Pointer Arithmetic with Arrays
In C, array names decay into pointers. Adding an integer to a pointer (pointer arithmetic) moves the pointer by that many elements, not bytes.
Open snippet →Code library
Intermediate C exercises
Read these Intermediate C snippets line by line — each one comes with a written breakdown of what the code does and why.
C · Intermediate
Dynamic Memory for Structs
Using malloc to allocate memory for structures on the heap is essential when the size or lifetime of the data isn't known at compile time.
Open snippet →C · Intermediate
Bitwise Flag Manipulation
Bitwise operators are used to store multiple boolean flags within a single integer, which is highly memory-efficient and fast.
Open snippet →C · Intermediate
Static Variables in Functions
A static local variable retains its value between function calls, initialized only once when the program starts.
Open snippet →C · Intermediate
Optimization with the restrict Keyword
The 'restrict' qualifier is a hint to the compiler that for the lifetime of the pointer, only the pointer itself or a value derived from it will be used to access the object it points to. This allo…
Open snippet →C · Intermediate
Variadic Functions using stdarg.h
Variadic functions allow you to pass a variable number of arguments to a function. This is achieved using the macros defined in <stdarg.h>. You must provide at least one fixed argument (like 'count…
Open snippet →C · Intermediate
Memory Efficiency with Unions
A union allows different data types to be stored in the same memory location. The size of the union is determined by its largest member. This is particularly useful in systems programming for overl…
Open snippet →C · Intermediate
Safe Multi-line Macros with do-while(0)
Wrapping a multi-statement macro in a 'do { ... } while (0)' block ensures it behaves as a single statement. This prevents logical errors when the macro is used inside 'if' statements without curly…
Open snippet →C · Intermediate
Designated Initializers for Structures
Designated initializers allow you to initialize structure members by name rather than by position. This makes code more robust against changes in the structure definition and improves readability b…
Open snippet →C · Intermediate
The volatile Type Qualifier
The 'volatile' keyword tells the compiler that a variable's value can change at any time without any action being taken by the code nearby. This prevents the compiler from applying optimizations th…
Open snippet →C · Intermediate
Compile-time Assertions with _Static_assert
_Static_assert (introduced in C11) allows checking conditions during the compilation phase rather than at runtime. If the condition is false, the compiler generates an error and stops, preventing t…
Open snippet →C · Intermediate
Inlining Functions for Performance
The 'inline' keyword is a hint to the compiler to replace function calls with the actual function body. This eliminates function call overhead (stack manipulation, jumping) for small, frequently us…
Open snippet →C · Intermediate
Passing Multidimensional Arrays to Functions
In C, multidimensional arrays are stored in row-major order. To correctly calculate memory offsets, a function receiving a 2D array must know the size of the columns (the second dimension), while t…
Open snippet →C · Intermediate
Safe String Formatting with snprintf
The snprintf function is a safer alternative to sprintf because it requires a maximum buffer size. This prevents buffer overflows by ensuring that no more than 'n' characters are written, including…
Open snippet →C · Intermediate
Atomic Operations with stdatomic.h
The stdatomic.h header (C11) provides types and functions for atomic operations, which are essential for thread-safe programming without the overhead of heavy locks. These operations are guaranteed…
Open snippet →C · Intermediate
Precise String Searching with strcspn
The strcspn function calculates the length of the initial segment of a string that consists entirely of characters NOT in a specified set. It is highly efficient for finding the first occurrence of…
Open snippet →C · Intermediate
Customizing Stream Buffering with setvbuf
The setvbuf function allows manual control over how a file stream (like stdout) is buffered. You can choose between fully buffered (_IOFBF), line buffered (_IOLBF), or unbuffered (_IONBF). Disablin…
Open snippet →C · Intermediate
Robust Numeric Parsing with strtol
Unlike the simpler atoi(), strtol() provides robust error checking and handles different number bases. It detects overflow, empty inputs, and tells you exactly where the numeric portion ends by upd…
Open snippet →C · Intermediate
Variadic Functions with stdarg.h
Variadic functions allow a function to accept an indefinite number of arguments. The 'stdarg.h' header provides macros like 'va_start', 'va_arg', and 'va_end' to traverse the argument list safely b…
Open snippet →C · Intermediate
Optimization with the restrict Qualifier
The 'restrict' keyword is a hint to the compiler that the pointer is the only means to access the object it points to within that scope. This eliminates potential 'pointer aliasing', allowing the c…
Open snippet →C · Intermediate
Unions for Type Punning
Unions allow the same memory location to be interpreted as different types. This 'type punning' is often used at an intermediate level to inspect the raw binary representation of data types like fl…
Open snippet →C · Intermediate
Structural Padding and offsetof
Compilers insert 'padding' bytes between structure members to ensure they are aligned with memory boundaries for performance. The 'offsetof' macro from 'stddef.h' allows you to see the exact byte o…
Open snippet →C · Intermediate
Dynamic Dispatch via Function Pointers
Function pointers allow functions to be passed as arguments, enabling dynamic behavior at runtime (callbacks).
Open snippet →C · Intermediate
Efficient Data Packing with Bit Fields
Bit fields allow defining structure members with a specific number of bits to save memory or map to hardware registers.
Open snippet →C · Intermediate
Avoiding Memory Leaks with realloc
When using realloc, always use a temporary pointer. If realloc fails, it returns NULL but the original memory remains allocated.
Open snippet →C · Intermediate
Custom Sorting with qsort and Callbacks
The standard qsort function uses a comparison callback to determine the sort order of any data type.
Open snippet →C · Intermediate
The Error-Cleanup Pattern with goto
In C, goto is often used to jump to a single cleanup block, ensuring resources are freed without duplicating code in multiple error checks.
Open snippet →C · Intermediate
Automatic Cleanup with atexit
The atexit function registers a callback that is automatically executed when the program terminates normally via return from main or exit(). This ensures that essential cleanup logic runs without n…
Open snippet →C · Intermediate
Array Decay and Pointer Arithmetic
In C, arrays 'decay' into pointers to their first element when passed to functions. This means the size information is lost inside the function. Use pointer arithmetic (ptr + offset) to navigate th…
Open snippet →C · Intermediate
Determining File Size with fseek and ftell
To measure a file's size without reading every byte, you can seek to the end of the stream and query the position. This is essential for allocating exactly enough memory to load a file's content in…
Open snippet →