Click any module to expand the full topic list. Every topic includes live trainer instruction, hands-on coding exercises on the platform, and assessment — not just lecture slides.
History, setup, compilation pipeline, and writing your first program
Origins at Bell Labs (Dennis Ritchie, 1972), ANSI C, C99, C11, C17, C23 standards. Why C remains relevant after 50+ years — OS kernels, embedded systems, compilers, databases.
Low-level access, portability, speed, structured programming. Where C is used today: Linux kernel, embedded firmware, IoT devices, game engines, database engines (SQLite, PostgreSQL).
Installing GCC/MinGW, configuring VS Code / Code::Blocks / Turbo C alternatives. Command-line compilation (gcc -o), understanding the terminal for C development.
Preprocessor directives, main function, statements, return values. Anatomy of #include, function prototypes, and the role of headers. Writing and running "Hello, World!"
The 4-stage process: preprocessing → compilation → assembly → linking. Understanding object files (.o), executables, and why this matters for debugging. Using gcc flags: -Wall, -g, -O2.
Single-line (//) and multi-line (/* */), indentation conventions, naming standards. Why clean code matters — readability for teams and interviews.
Who can read, write, and execute what — the Linux security model
int, float, double, char — sizes, ranges, and memory layout. sizeof operator. Understanding why int is 4 bytes and char is 1 byte on modern systems.
short, long, signed, unsigned — how they change storage and range. const, volatile, and register qualifiers. When to use unsigned vs signed.
Declaration vs definition vs initialisation. Integer, floating-point, character, and string literals. #define constants vs const variables — when to use which.
Implicit (automatic) vs explicit (manual) type casting. Integer promotion rules. Common bugs: float truncation, sign extension, loss of precision. Using (type) cast syntax.
+, -, *, /, % (with integer vs float division gotchas). ==, !=, <, >. &&, ||, ! — short-circuit evaluation and its impact on code correctness.
&, |, ^, ~, <<, >> — how they manipulate individual bits. Practical uses: flags, masking, power-of-2 checks, swapping without temp variable. Interview favourites.
Compound assignment (+=, -=), ternary (? :), comma operator. Operator precedence and associativity — the table every C programmer must know.
Creating readable code with enums. typedef for type aliasing. Using typedef with structs and function pointers for cleaner APIs.
Reading input, producing output, and controlling program execution path
Format specifiers (%d, %f, %c, %s, %x, %o, %p), width/precision modifiers, escape sequences (\n, \t, \\). Common scanf pitfalls: buffer overflow, newline in buffer.
Single-character input/output. Why gets() is dangerous (buffer overflow) and fgets() is the safe alternative. Reading entire lines vs words.
Conditional execution, nested conditions, dangling else problem. Writing clean conditional logic — when to use if-else chains vs switch.
Multi-way branching, fall-through behaviour, break and default. When switch is better than if-else (integer/char comparisons). Nested switch statements.
Entry-controlled vs exit-controlled loops. Infinite loops, loop counters, off-by-one errors. Choosing the right loop for each scenario.
Breaking out of loops, skipping iterations, and (rarely) using goto. Nested loop break patterns. Why goto is discouraged but exists — and when it's acceptable (error cleanup in C).
Storing collections of data and manipulating text
Memory layout of arrays, index-based access, array bounds (no runtime checking in C). Initialisation: partial, complete, designated initialisers (C99).
Searching (linear, binary), sorting (bubble, selection, insertion), reversing, rotating, merging. Building algorithmic thinking through array manipulation.
Row-major storage, matrix declaration and traversal. Addition, subtraction, multiplication, transpose. Passing 2D arrays to functions.
Null-terminated strings ('\0'), string declaration, initialisation. The difference between char str[] and char *str. String input with scanf, fgets.
strlen, strcpy, strcat, strcmp, strstr, strtok, sprintf, sscanf. Implementing these from scratch — a common interview exercise.
2D char arrays, array of char pointers. Sorting an array of strings. Command-line argument basics (argv as array of strings).
Modular programming, reusable code, and understanding variable lifetime
Return types, parameters, calling conventions. Why prototypes matter — the compiler's perspective. void functions. Functions returning multiple values via pointers.
Why C is "always call by value" but achieves call-by-reference through pointers. Swapping two numbers — the classic demonstration. Passing arrays to functions (always by reference).
Base case, recursive case, stack frames. Classic problems: factorial, Fibonacci, Tower of Hanoi, power function. Understanding stack overflow and tail recursion.
Variable lifetime, scope, and linkage. static local variables (persistent across calls), extern for multi-file linking, register for optimisation hints. Interview favourite topic.
Block scope, function scope, file scope, program scope. Name resolution when inner and outer variables share names. Avoiding scope-related bugs.
Functions with variable arguments using stdarg.h (va_list, va_start, va_arg, va_end). How printf itself works under the hood. Writing your own variadic functions.
The heart of C — memory addresses, heap allocation, and pointer arithmetic
What a pointer IS (a variable storing an address), declaration (*), referencing (&), dereferencing (*). NULL pointers and void pointers. Visualising memory with pointer diagrams.
Incrementing/decrementing pointers, pointer subtraction, comparison. How pointer arithmetic relates to the data type's size. Traversing arrays with pointers vs indices.
Array name as a pointer, arr[i] vs *(arr+i). Pointer to array vs array of pointers. 2D array access through pointer notation. The decay rule.
char* vs char[]: string literals vs mutable character arrays. String manipulation through pointers. Common pitfalls: modifying string literals (segfault).
int **pp — when and why. Dynamic 2D array allocation. Modifying a pointer inside a function (passing pointer's address).
Declaring and using function pointers. Callback functions. Sorting with custom comparators (qsort). Building simple dispatch tables — a pattern used in embedded systems and OS kernels.
Heap vs stack allocation. When to use each function. Memory leaks — how they happen and how to prevent them. Dangling pointers and double-free bugs.
Segmentation faults, wild pointers, memory corruption. Using tools: Valgrind for leak detection, AddressSanitizer (gcc -fsanitize=address). Defensive programming patterns.
User-defined data types for organising complex data
Defining struct, accessing members (dot operator), initialising with designated initialisers (C99). Structures as building blocks for complex data — student records, coordinates, linked list nodes.
Structures containing other structures. Creating arrays of structs for real-world data (employee database, product inventory). Sorting an array of structs.
Accessing members through pointers using ->. Dynamic allocation of structs. Passing structures to functions by value vs by pointer (performance implications).
Structures that point to themselves — the foundation for linked lists, trees, and graphs in C. Implementing a singly linked list node: struct Node { int data; struct Node *next; };
Shared memory storage — all members occupy the same address. Size calculation (sizeof union). Practical use: variant types, protocol parsing, memory-efficient data representation.
Allocating specific bit widths to struct members. Memory-efficient flag storage. Packing data for embedded systems and network protocols.
Persistent data, build systems, and writing production-quality C
Opening files in read/write/append modes. Text files vs binary files. Reading/writing characters (fgetc, fputc), strings (fgets, fputs), and formatted data (fprintf, fscanf).
fseek, ftell, rewind for random access. feof, ferror for error detection. Proper file cleanup patterns — always close what you open.
argc and argv — receiving input from the terminal. Parsing flags and filenames. Building a simple command-line tool (e.g., file word counter).
#include, #define, #undef, #ifdef, #ifndef, #pragma. Conditional compilation for platform-specific code. Include guards to prevent double inclusion.
Simple text substitution macros, parameterised macros, common pitfalls (side effects, missing parentheses). Macros vs inline functions — when to use which.
Splitting programs across .c and .h files. extern declarations, static functions (file-scope linkage). Separate compilation: gcc file1.c file2.c -o program. Understanding Makefiles basics.
errno, perror, strerror for system error reporting. Return-code-based error handling patterns. Why C doesn't have exceptions — and what it uses instead.
Not just lectures — students write, compile, and run real programs throughout. Here are the types of exercises and mini-projects included:
Stars, numbers, alphabets, pyramids, diamonds — the loop mastery exercises every placement asks.
Prime checking, GCD/LCM, Fibonacci, factorial, Armstrong numbers, digit manipulation.
Reverse, palindrome, anagram detection, word count, character frequency — implementing string.h from scratch.
Sorting (bubble, selection, insertion), searching (linear, binary), rotation, merge, and duplicate detection.
Build a singly linked list with insert, delete, search, and reverse — using structs and pointers.
Student record system or address book — file read/write, struct storage, menu-driven CLI interface.
Expert trainers explain concepts, code live, and solve problems interactively. 3–5 sessions per week, each 1.5–2 hours.
Between sessions, students solve C problems — real GCC compiler, automated test cases, AI concept hints. Daily practice builds fluency
Timed coding tests + MCQs every week, auto-evaluated. Topic-wise analytics show and detailed concepts need reinforcement.
Student-wise dashboards for trainers and TPOs. Who's on track? Which topics are class-wide weak spots? Data drives intervention.
TCS NQT, Wipro NLTH, and Infosys SP all include C-specific MCQs in their technical sections — pointer output prediction, sizeof questions, storage class behaviour. Students who skip C lose marks in these sections.
Pointers, stack vs heap, memory allocation, buffer overflows — concepts no other mainstream language exposes. Students who learn C first understand what Java and Python abstract away. This depth shows in interviews.
Bosch, Samsung, Qualcomm, Intel, Texas Instruments, ISRO — embedded and systems companies hire exclusively in C/C++. For ECE students, C is the only language that matters for their target employers.
C++ adds OOP on top of C. DSA is best learned in C/C++ for memory understanding. Operating systems, compilers, and databases are written in C. Mastering C makes every subsequent module easier.
E-305, Industrial Area, Sahibzada Ajit Singh Nagar, Punjab 160055, IN
