C Programming (from zero to systems)

Learn what C is and why it still runs the world's systems, install a compiler, compile and run programs with gcc, understand the structure of a C program, the basic data types and their sizes, and input and output with printf and scanf. After this module you can write, compile and run small C programs that read input and print formatted results.

1. What C is and why it still mattersC is a small, fast, compiled language created by Dennis Ritchie at Bell Labs in the early 1970s. It gives direct control over memory and hardware, which is why operating systems, databases, language interpreters and embedded devices are written in it. Learning C teaches you how computers really work underneath every other language.20 min
2. Compiling with gccgcc turns a .c file into an executable in four stages: preprocess, compile, assemble and link. The everyday command is gcc -std=c17 -Wall -Wextra -g hello.c -o hello, then ./hello to run it. Warnings point to real bugs, so read them and fix them; -Werror turns them into errors.30 min
3. The structure of a C programA C program is a set of functions, and execution starts at main. #include lines bring in declarations from header files such as stdio.h. Statements end with semicolons, braces group them into blocks, and comments are written with /* … */ or //. main returns an int: 0 for success.20 min
4. Data types and their sizesC has char, short, int, long and long long for whole numbers (signed or unsigned), and float and double for decimals. Their sizes depend on the platform: on typical 64-bit Linux, int is 4 bytes and long is 8, but on 64-bit Windows long is 4. Use sizeof to check, limits.h for ranges, and stdint.h types like int32_t when you need an exact size. Uninitialised local variables hold garbage.30 min
5. Input and output: printf and scanfprintf prints formatted output using specifiers such as %d, %f, %c, %s, %x and %p, with optional width and precision (%8.2f). scanf reads input into variables and needs their addresses (&n). Always check scanf's return value, read lines safely with fgets, and never use %s without a width limit.30 min

Calculate with C's operators (and avoid their traps: integer division, increments, precedence), understand type conversion and casting, make decisions with if and switch, repeat work with every kind of loop, and solve classic number problems. After this module you can write C programs that make decisions and loop correctly, such as a digit-sum checker or a prime finder.

1. OperatorsC has arithmetic (+ - * / %), increment and decrement (++ --), assignment (= += -=), relational (== != < > <= >=) and logical (&& || !) operators. Dividing two integers gives an integer (7 / 2 is 3, and -7 / 2 is -3). In C, 0 is false and any non-zero value is true. Modifying a variable twice in one expression, as in i = i++ + ++i, is undefined behaviour.25 min
2. Type conversion and castingC converts types automatically in expressions: small integers (char, short) become int ("integer promotion"), and mixed operands are converted to a common type, such as int to double. Mixing signed and unsigned can surprise you: -1 < 1U is false. A cast like (double) total / count forces a conversion; converting a double to int truncates.20 min
3. Decisions: if, else and switchif runs code when a condition is non-zero; else if and else cover the other cases. switch jumps to the case matching an integer or char value; each case needs break, or execution falls through into the next. The ternary operator chooses between two values. Beware if (x = 5), which assigns instead of comparing.25 min
4. Loops: for, while and do-whilefor loops are for counting, while loops repeat while a condition is true, and do-while runs its body at least once. break leaves a loop and continue skips to the next round; for (;;) is an infinite loop ended by break. Watch out for off-by-one errors and the stray semicolon after for (...).25 min
5. Solving problems with loopsClassic beginner problems train loop thinking: sum and reverse the digits of a number with % 10 and / 10, check whether a number is prime by testing divisors up to its square root, find the greatest common divisor with Euclid's algorithm, and generate Fibonacci numbers. These appear in almost every C interview and placement test.30 min

Organise C code into functions with prototypes and return values, understand scope and storage classes (local, global, static, extern), write recursive functions, and store data in one- and two-dimensional arrays with the classic search and sort algorithms. After this module you can write well-structured C programs that process lists and tables of data.

1. FunctionsA function is a named block of code with parameters and a return type. Declare it before use with a prototype (int area(int w, int h);) and define it anywhere. C passes arguments by value: the function gets copies, so changing a parameter does not change the caller's variable (pointers, in module 5, change that). void means "returns nothing" or "takes nothing".25 min
2. Scope and storage classesScope is where a name can be used; lifetime is how long the variable exists. Local (automatic) variables live inside a block for one call. Global variables live for the whole program. A static local variable keeps its value between calls, static on a global variable or function makes it private to its file, and extern declares a global defined in another file.25 min
3. RecursionA recursive function calls itself on a smaller version of the problem. It needs a base case that stops the recursion and a recursive case that moves toward it. Each call gets its own stack frame; too many nested calls overflow the stack and crash the program (usually a segmentation fault). Naive recursive Fibonacci is very slow; loops are often better in C.25 min
4. ArraysAn array stores a fixed number of elements of one type in consecutive memory, indexed from 0. int marks[5] = {0}; zeroes all five. sizeof(arr) / sizeof(arr[0]) gives the count only where the array is declared. C never checks bounds: reading or writing outside the array is undefined behaviour. When passed to a function, an array becomes a pointer, so pass its length too.25 min
5. 2D arrays and classic array algorithmsA 2D array like int seats[10][20] is a grid of rows and columns stored row after row in memory (row-major order). When passing one to a function, every dimension except the first must be given: void show(int g[][20], int rows). Classic algorithms on arrays include linear and binary search, finding the min and max, reversing in place, and simple sorts like bubble and selection sort.30 min

Understand C strings as char arrays ending in a null character, use the <string.h> functions correctly (and know their traps), read text input safely, work with characters through <ctype.h>, and prevent buffer overflows. After this module you can process names, codes and lines of text in C without the classic crashes and security holes.

1. Strings are char arraysC has no string type. A string is an array of char that ends with the null character '\0', which marks where the text stops. char s[] = "Hi"; makes an array of 3 chars: H, i and \0. String literals are read-only, so changing one through a pointer is undefined behaviour. Print strings with %s.25 min
2. The <string.h> functions<string.h> provides strlen (length without the \0), strcpy and strcat (copy and append, with no size checks), strncpy and strncat (with limits, but traps), strcmp (compare; 0 means equal), strchr and strstr (search), and memcpy and memset for raw bytes. snprintf(buf, sizeof buf, …) is the safest general way to build strings.30 min
3. Reading strings safelyRead lines of text with fgets(buf, sizeof buf, stdin): it never writes past the buffer, keeps the newline (remove it with buf[strcspn(buf, "\n")] = '\0'), and returns NULL at end of input. gets() was removed from C in 2011 because it cannot be used safely. scanf("%s") stops at spaces and needs a width. Convert text to numbers with strtol and check for errors, instead of atoi.25 min
4. Characters and <ctype.h>A char is a small integer holding a character code; in ASCII, 'A' is 65, 'a' is 97 and '0' is 48. So c - '0' turns a digit character into its number. <ctype.h> provides isalpha, isdigit, isspace, isupper, toupper and tolower; pass them an unsigned char value. These tools power validation, counting and simple ciphers.25 min
5. Buffer overflows and safe string handlingA buffer overflow happens when a program writes past the end of an array, overwriting other data. In C it is undefined behaviour and one of the most exploited classes of security bugs. Prevent it by tracking sizes everywhere, using bounded functions (fgets, snprintf), checking lengths before copying, and turning on compiler protections and AddressSanitizer while testing.30 min

Master the topic that makes C powerful and feared: addresses and pointers, passing pointers to functions, the relationship between arrays and pointers, pointer arithmetic, and pointer pitfalls (NULL, wild and dangling pointers, pointers to pointers). Every idea is drawn as a memory diagram. After this module you can read and write pointer code confidently and explain it in interviews.

1. Addresses and pointersMemory is a long row of numbered bytes, and every variable lives at some address. The & operator gives a variable's address; a pointer is a variable that stores an address. If int *p = &x;, then *p (dereferencing) reads or writes x itself. On 64-bit systems a pointer is 8 bytes. Print addresses with %p and a (void *) cast.30 min
2. Pointers and functionsBecause C passes arguments by value, a function can only change a caller's variable if it receives that variable's address. Passing &x lets swap, scanf and "return several results" functions write to the caller's variables. Never return the address of a local variable. const int *p means "cannot change what p points to"; int *const p means "p cannot point elsewhere".30 min
3. Pointers and arraysIn most expressions an array name "decays" to a pointer to its first element, so a and &a[0] are the same address, and a[i] means exactly *(a + i). That is why arrays passed to functions arrive as pointers. But an array is not a pointer: sizeof differs, and you cannot assign to an array. Strings are walked with char pointers.30 min
4. Pointer arithmeticAdding 1 to a pointer moves it to the NEXT element, not the next byte: for an int pointer, p + 1 is 4 bytes further on typical systems. Subtracting two pointers into the same array gives the number of elements between them (type ptrdiff_t). Pointers can point one past the end of an array but must not be dereferenced there, and arithmetic outside the array is undefined.25 min
5. NULL, dangling pointers and pointers to pointersNULL is a pointer that points nowhere; dereferencing it crashes (a segmentation fault on most systems), so check pointers before use. Uninitialised (wild) pointers and dangling pointers (to memory that was freed or went out of scope) are worse, because they may seem to work. A pointer to a pointer (int **pp) lets a function change the caller's pointer. Read complex declarations from the name outward.30 min

Understand how a C program's memory is laid out (stack versus heap), allocate memory at run time with malloc, calloc and realloc, release it correctly with free, build growable arrays, and find leaks, use-after-free and double-free bugs with valgrind and AddressSanitizer. After this module you can manage heap memory safely, a core skill for systems and embedded interviews.

1. Stack and heapA running C program's memory has regions: code (text), global and static data, the heap and the stack. Local variables live on the stack and disappear when their function returns. The heap holds memory you request at run time with malloc; it stays until you free it. Use the heap when the size is known only at run time or the data must outlive the function.25 min
2. malloc, calloc and freemalloc(n) returns a pointer to n bytes of uninitialised heap memory, or NULL if it fails. calloc(count, size) allocates and zeroes. free(p) returns the block; call it exactly once per allocation, and never on memory you did not allocate. Use the p = malloc(n * sizeof *p) idiom, check for NULL, and set p = NULL after free.30 min
3. realloc and growing arraysrealloc(p, new_size) resizes a heap block, possibly moving it to a new address and copying the contents. If it fails it returns NULL and leaves the old block alive, so always assign the result to a temporary first. A dynamic array keeps a size and a capacity and doubles the capacity when full, which makes adding n items cost O(n) in total (amortised O(1) each).30 min
4. Memory leaks and other heap bugsThe classic heap bugs are leaks (memory never freed), use-after-free, double free, heap buffer overflows, freeing memory not from malloc, and reading uninitialised memory. They cause slow growth, crashes and security holes. valgrind (memcheck) and AddressSanitizer (-fsanitize=address) find them, pointing at the exact lines where memory was allocated, freed and misused.30 min
5. Dynamic strings and 2D arraysTo store text whose length is known only at run time, allocate strlen + 1 bytes (or use strdup, standard since C23 and long available in POSIX) and free it later. A 2D table of run-time size can be an array of row pointers (each row allocated separately) or one contiguous block indexed as row * cols + col. Free rows before the row array.25 min

Group related data with structs and typedef, use pointers to structs and the -> operator, name constants with enums, share memory with unions, understand padding and alignment, and read and write text and binary files safely. After this module you can model real records such as students, orders and sensor readings, and save and load them from files.

1. StructsA struct groups variables of different types into one record, such as a student with a name, a roll number and marks. Access members with the dot operator (s.roll). Designated initialisers (.roll = 7) make initialisation clear. Structs can be copied with = and passed to or returned from functions by value. typedef gives the type a shorter name.25 min
2. Pointers to structs and the arrow operatorp->field is a shortcut for (*p).field and is how you reach members through a pointer. Passing a pointer to a struct avoids copying and lets the function change the caller's struct; use const when it only reads. Structs are often allocated on the heap, can contain other structs, and can contain a pointer to their own type, which is how linked lists are built.25 min
3. Unions, enums and memory layoutAn enum gives names to integer constants (enum Status { PENDING, PAID, FAILED }), making code readable and switch statements clear. A union lets several members share the same memory, so it is as big as its largest member and only one member is meaningful at a time; a tagged union adds an enum to record which. The compiler inserts padding inside structs for alignment, so field order changes sizeof.25 min
4. Reading and writing text filesfopen(path, mode) opens a file and returns a FILE *, or NULL on failure; always check it and report the reason with perror. Modes include "r" (read), "w" (write, truncating), "a" (append) and "r+". Write with fprintf and fputs, read with fgets or fscanf, and always fclose. Loop on the read function's return value, not on feof.30 min
5. Binary files and recordsBinary files store data as raw bytes, the same way it sits in memory. fwrite and fread copy whole structs or arrays in one call, and fseek, ftell and rewind move around the file, which allows fixed-size record databases with random access. Open binary files with "rb"/"wb", and remember that raw structs are not portable across compilers and platforms because of padding, sizes and byte order.25 min

Understand what the preprocessor does before compilation (macros, conditional compilation, include guards), split programs into header and source files, read linker errors, build projects with make and Makefiles, and create and use static and shared libraries. After this module you can organise and build a multi-file C project the way real teams do.

1. The preprocessor and macrosBefore compiling, the preprocessor handles lines that start with #: it pastes in #include files and replaces #define macros as plain text. Object-like macros name constants; function-like macros look like functions but are text substitution, so always put brackets around parameters and the whole body, and beware arguments with side effects. Prefer const variables and static inline functions where possible.25 min
2. Conditional compilation and include guards#if, #ifdef, #ifndef, #else and #endif keep or remove code before compilation, so one source can build debug and release versions or support Linux and Windows. Define flags in code or on the command line with gcc -DDEBUG. Every header needs an include guard (#ifndef NAME_H / #define NAME_H / #endif, or #pragma once) so including it twice does not cause errors.20 min
3. Splitting a program into filesReal C programs are split into modules: a header (.h) declares what a module offers (types, function prototypes, extern variables), and a source file (.c) defines it. Each .c file is compiled separately into an object file (gcc -c), and the linker joins them. "undefined reference" means something was declared but never defined (or not linked); "multiple definition" means it was defined in more than one file.25 min
4. Building with makemake reads a Makefile of rules: a target, its prerequisites and a recipe (commands, indented with a TAB). It rebuilds only targets whose prerequisites changed, which saves time in big projects. Variables like CC and CFLAGS keep settings in one place, pattern rules (%.o: %.c) cover every source file, and .PHONY marks targets like clean that are not files.25 min
5. Libraries: static and sharedA library packages compiled code for reuse. A static library (libx.a, made with ar) is copied into each executable at link time. A shared library (libx.so on Linux, .dll on Windows, .dylib on macOS) is loaded at run time and shared between programs. Link with -I (header folders), -L (library folders) and -lname (the library), for example -lm for the math library.25 min

Work at the level of individual bits with bitwise operators, masks and flags, understand undefined, unspecified and implementation-defined behaviour and how compilers exploit them, write secure and defensive C following industry rules, and use function pointers for callbacks and qsort. After this module you can read low-level and embedded code and avoid the traps that cause crashes and security holes.

1. Bitwise operatorsBitwise operators work on the individual bits of integers: & (AND), | (OR), ^ (XOR), ~ (NOT), << (shift left) and >> (shift right). Shifting left by n multiplies by 2^n and shifting right divides (for unsigned values). Use unsigned types for bit work: shifting negative numbers or shifting by the type's width or more is implementation-defined or undefined.30 min
2. Masks and flagsA mask selects certain bits. The four basic operations on bit n of x are: set (x |= 1u << n), clear (x &= ~(1u << n)), toggle (x ^= 1u << n) and test (x & (1u << n)). Flags pack many yes/no options into one integer, as Linux file permissions do (0755). Masks and shifts also extract fields from packed values such as hardware register readings.25 min
3. Undefined behaviourUndefined behaviour (UB) means the C standard places no requirements at all on what happens: a crash, wrong output, or apparently correct results that change with the compiler or optimisation level. Common causes are signed overflow, out-of-bounds access, NULL or dangling pointer use, uninitialised reads, unsequenced modifications and over-wide shifts. Optimisers assume UB never happens, which can remove your safety checks. Use -fsanitize=undefined to find it.30 min
4. Secure and defensive CDefensive C assumes inputs can be wrong or hostile and that every call can fail. Validate input at the boundary, check every return value (malloc, fopen, scanf, read), use size_t for sizes and check multiplications before allocating, avoid unbounded functions, compile with warnings and hardening flags, and follow an industry rule set such as SEI CERT C or, in automotive and other safety-critical work, MISRA C.25 min
5. Function pointers and callbacksA function pointer stores the address of a function, so code can choose at run time which function to call. Declare one as int (*op)(int, int), assign a function name, and call it like a function. Arrays of function pointers make dispatch tables (menus, state machines), and passing them as callbacks lets libraries like qsort call your code. typedef makes the syntax readable.30 min

Build the classic data structures by hand in C, with structs, pointers and malloc: singly linked lists, stacks, queues and circular buffers, binary search trees and hash tables. Each one is drawn as a memory diagram and its algorithm is also given as a JavaScript task that runs here. After this module you can implement and explain these structures in interviews and choose the right one for a job.

1. Singly linked listsA linked list stores elements in separate heap nodes; each node holds a value and a pointer to the next node, and the last points to NULL. Inserting at the head is O(1) and the list grows one node at a time, but reaching the k-th element means walking from the head (O(n)). Deleting cleanly uses a pointer-to-pointer, and the whole list must be freed node by node.30 min
2. StacksA stack is last-in, first-out (LIFO): push adds on top, pop removes the top, peek looks at it. In C, a stack is easily built on an array with a top index (check for overflow and underflow) or on a linked list (push and pop at the head). Stacks power undo features, function calls, expression evaluation and bracket matching.25 min
3. Queues and circular buffersA queue is first-in, first-out (FIFO): enqueue at the tail, dequeue from the head. A plain array queue wastes space as the head moves forward, so C programs use a circular buffer: head and tail indexes wrap around with % capacity, and a count (or one empty slot) tells full from empty. Circular buffers are everywhere in embedded systems, for example receiving serial (UART) data.30 min
4. Binary search treesA binary search tree (BST) is made of nodes with a value and left and right child pointers; every value in the left subtree is smaller and every value in the right subtree is larger. Search and insert follow one path from the root, which takes O(log n) when the tree is balanced but O(n) if it degenerates into a chain. An in-order traversal visits the values in sorted order.30 min
5. Hash tablesA hash table maps keys to values in about O(1) time. A hash function turns a key (like a string) into a number, which picks a bucket in an array. Different keys can land in the same bucket (a collision), so each bucket holds a small linked list (chaining). Keep the load factor (items ÷ buckets) low by growing and rehashing when it gets high.30 min

Use the professional C toolbox: step through programs and find crash locations with gdb, catch memory errors with valgrind, catch them faster with AddressSanitizer and UndefinedBehaviorSanitizer, turn on strict warnings and static analysers, test code with assert and small test harnesses, and follow a calm method for any bug. After this module you can find and fix crashes and memory bugs like an experienced C developer.

1. Debugging with gdbgdb (the GNU debugger) runs your program under control: set breakpoints, step line by line, print variables, and see the call stack. Compile with -g -O0 first. After a crash such as a segmentation fault, run the program in gdb and type bt (backtrace) to see exactly which line and which chain of calls caused it.30 min
2. Finding memory bugs with valgrindvalgrind's memcheck tool runs your unmodified program on a simulated CPU and reports invalid reads and writes, use of uninitialised values, invalid frees and memory leaks, with the source lines involved. Run valgrind --leak-check=full ./prog on a -g build. It works on Linux (and WSL on Windows) and slows the program down a lot, so use it on test inputs.25 min
3. Sanitizers and warningsSanitizers are compiler instrumentation that checks your program while it runs: AddressSanitizer (-fsanitize=address) finds out-of-bounds accesses, use-after-free and leaks; UndefinedBehaviorSanitizer (-fsanitize=undefined) finds signed overflow, bad shifts and more. They are much faster than valgrind. Combine them with strict warnings (-Wall -Wextra -Wpedantic -Wshadow -Wconversion) and static analysers to catch bugs before they ship.25 min
4. assert, logging and testing C codeassert(condition) from <assert.h> stops the program with the file, line and condition when an assumption is false; it is removed when NDEBUG is defined, so use it for programmer errors, not for user input. Report expected failures with return codes and errno. Test C code with a small home-made CHECK macro or a framework such as Unity, CMocka or Check, covering edge cases.25 min
5. A method for debuggingGood debugging is a method, not luck: reproduce the bug reliably, shrink it to the smallest failing case, read every error and warning, form a hypothesis, test it with a tool (gdb, sanitizers, prints), fix the cause rather than the symptom, and add a test. Most C crashes come from a short list of causes worth checking first.20 min

See where C is used professionally: programming microcontrollers (registers, volatile, interrupts, timing and tight memory), talking to Linux through system calls, answering the classic C interview questions, and planning projects and a career in embedded, firmware and systems roles. After this module you can explain how C controls hardware and the operating system, and prepare confidently for C-heavy jobs.

1. Embedded C basicsEmbedded C runs on microcontrollers: small chips with a processor, a little RAM and flash memory, and pins that control the outside world. Hardware is controlled through memory-mapped registers, accessed with volatile pointers to fixed addresses, using bit masks to set individual pins. Code is cross-compiled on a PC (for example with arm-none-eabi-gcc) and flashed onto the chip.30 min
2. Embedded patterns: interrupts, timing and constraintsFirmware is usually a "super loop" that checks inputs and updates outputs forever, helped by interrupts: hardware events that pause the loop and run a short interrupt service routine (ISR). ISRs must be quick and share data with the main loop through volatile variables and careful design. Debounce buttons, avoid blocking delays, avoid malloc in many projects, and follow rules like MISRA C in safety-critical products.25 min
3. C on Linux: files and processes with system callsOn Linux, programs ask the kernel for services through system calls. File I/O at this level uses integer file descriptors (0 = stdin, 1 = stdout, 2 = stderr) with open, read, write and close; printf and fopen are library layers built on top of them. Failures return -1 and set errno (print it with perror). fork creates a new process, exec replaces its program, and wait collects its exit status.30 min
4. C interview questionsC interviews (embedded, systems, product and service companies) return to the same topics: pointers versus arrays, malloc versus calloc, the meanings of static, volatile and const, struct padding, endianness, macros versus inline functions, dangling pointers and segmentation faults, call by value, and many "what does this print?" snippets. Answer briefly, with a small example, and mention undefined behaviour where it applies.30 min
5. Projects and careers with CC leads to embedded software and firmware engineering, Linux kernel and device-driver work, systems programming (databases, networking, compilers), automotive software (often with AUTOSAR and MISRA C) and IoT development. Build a few hardware and systems projects, publish them with clear READMEs, learn Linux and debugging tools well, and keep salary expectations honest.25 min