C & C++ Programming Course

• How a computer executes a program: CPU, memory, source code versus machine code
• The build pipeline: preprocessing, compilation, assembly and linking, and what each stage produces
• Installing the toolchain: GCC/G++ through MinGW-w64 or MSYS2 on Windows, Clang via Xcode Command Line Tools on macOS, GCC on Linux; setting up VS Code or Code::Blocks
• Compiling from the terminal: gcc main.c -o main, the -Wall, -Wextra and -std flags, and how to read compiler errors and warnings
• Anatomy of a C program: #include, main(), return codes and comments
• Data types: int, char, float, double, sizes with sizeof, signed versus unsigned and type limits
• Variables, constants, literals and type conversions (implicit promotion and explicit casts)
• Formatted input and output with printf and scanf: format specifiers and common pitfalls

Outcome: You can install a working toolchain, compile from the command line with warnings enabled and write simple programs that read input and print formatted output.

• Arithmetic, relational, logical, bitwise, assignment and increment/decrement operators
• Operator precedence and associativity, integer division, the modulo operator and integer overflow
• Decision making: if/else, else-if ladders, nested conditions and the ternary operator
• switch statements and intentional versus accidental fall-through
• Loops: while, do-while and for; designing loops that terminate correctly
• break, continue and nested loops
• Logic-building problems: pattern printing, primes, GCD and LCM, digit manipulation and Fibonacci numbers
• Dry-running code: tracing variables by hand to find logic errors before they happen

Outcome: You can translate a problem statement into correct conditional and loop logic and trace any loop by hand.

• Declaring, defining and calling functions; function prototypes
• Parameters, return values and pass-by-value semantics
• Scope and lifetime: local, global, static and extern variables; storage classes
• The call stack: how stack frames are created and destroyed
• Recursion: base case, recursive case and drawing a recursion tree
• Classic recursive problems: factorial, fast power, Fibonacci, sum of digits and the Tower of Hanoi
• Recursion versus iteration and the hidden cost of naive recursion
• Debugging with breakpoints, step-in/step-over and watches in GDB or an IDE debugger

Outcome: You can break programs into well-named functions, write and trace recursive solutions, and inspect the call stack in a debugger.

• One-dimensional arrays: declaration, initialization, traversal and bounds
• Passing arrays to functions and what the function actually receives
• Core array algorithms: linear search, binary search, reversal, rotation, prefix sums and frequency counting
• Two-dimensional arrays and matrices: traversal patterns, transpose and matrix multiplication
• C strings: null-terminated character arrays and string literals
• <string.h> functions: strlen, strcpy/strncpy, strcmp, strcat; safe line input with fgets
• String problems: palindromes, reversal, counting characters and words, anagram checks
• Buffer overflows and off-by-one errors: why bounds checking matters

Outcome: You can solve array and string problems confidently and avoid the off-by-one and buffer errors that crash C programs.

• Memory addresses, the address-of (&) and dereference (*) operators, and pointer declarations
• Pointer arithmetic and how it depends on the size of the pointed-to type
• Pointers and arrays: array-to-pointer decay and why a[i] equals *(a + i)
• Pointers and functions: simulating pass-by-reference, writing swap, returning pointers safely
• Double pointers, arrays of pointers and const with pointers
• Function pointers and callbacks, including qsort with a custom comparator
• Dynamic memory: malloc, calloc, realloc and free; the stack versus the heap
• Dynamic one- and two-dimensional arrays on the heap
• Memory leaks, dangling pointers, double free and NULL checks; finding bugs with Valgrind and AddressSanitizer

Outcome: You can read and write pointer-heavy code, draw its memory diagram, and allocate and free heap memory without leaks.

• struct: definition, initialization, nested structures and arrays of structures
• Pointers to structures, the arrow (->) operator and typedef
• Structure padding and alignment (introduction)
• Unions and enums: what they are for and when to use them
• Self-referential structures: building a singly linked list with insert, delete and traverse
• File handling: fopen/fclose and modes, fprintf/fscanf, fgets/fputs, binary I/O with fread/fwrite, error handling
• Command-line arguments with argc and argv
• The preprocessor: #define, macros and their pitfalls, conditional compilation and include guards
• Multi-file programs: header files, separate compilation, linking and a simple Makefile

Outcome: You can model real-world records, save them to files and structure a C project across multiple source files. This completes the C foundation.

• Why C++: compatibility with C, zero-cost abstractions and where C++ is used
• Stream I/O with <iostream>, namespaces and std::string
• References versus pointers, const references and pass-by-reference
• Function overloading, default arguments and inline functions
• new/delete compared with malloc/free
• Classes and objects: data members, member functions and access specifiers
• Constructors (default, parameterized, copy), member initializer lists and destructors
• Encapsulation, the this pointer, static members and const member functions

Outcome: You can write idiomatic C++ classes that manage their own state and explain how C++ builds on C.

• Inheritance: base and derived classes; public, protected and private inheritance
• Single, multilevel, hierarchical and multiple inheritance; the diamond problem and virtual inheritance
• Order of constructor and destructor calls in a hierarchy
• Compile-time polymorphism (overloading) versus run-time polymorphism (virtual functions and overriding, with override and final)
• How virtual dispatch works: vtables and vptrs, explained conceptually
• Abstract classes, pure virtual functions, interfaces and why base classes need virtual destructors
• Operator overloading: arithmetic, comparison, subscript and stream operators (<<, >>); member versus friend functions
• Copy constructors, copy assignment, deep versus shallow copy and the rule of three/five
• OOP design exercise: modeling a small domain with classes and simple UML class diagrams

Outcome: You can design class hierarchies that use polymorphism correctly and overload operators so your own types feel natural to use.

• Function templates, class templates and how templates are instantiated
• Exceptions: try, throw and catch; standard exception classes; custom exception types; exception-safety basics
• RAII: tying the lifetime of a resource to the lifetime of an object
• Smart pointers: std::unique_ptr, std::shared_ptr, std::weak_ptr, make_unique and make_shared
• Modern syntax: auto, range-based for loops, brace initialization, nullptr and an introduction to constexpr
• Lambda expressions: syntax, capture lists and use with standard algorithms
• Introduction to move semantics: lvalues and rvalues, std::move, move constructors and move assignment
• std::pair, std::tuple and structured bindings

Outcome: You can write generic, exception-safe modern C++ that releases memory automatically, and you can read modern C++ code with confidence.

• How the STL is organized: containers, iterators, algorithms and function objects
• Sequence containers: vector (size, capacity, reserve), list, deque and array
• Container adaptors: stack, queue and priority_queue, including min-heaps and custom comparators
• Ordered associative containers: set, multiset, map and multimap
• Hash-based containers: unordered_set and unordered_map; average versus worst-case behavior
• Iterators: begin/end, iterator categories and iterator invalidation
• Algorithms: sort with custom comparators, stable_sort, binary_search, lower_bound/upper_bound, find, count, accumulate, reverse, min_element/max_element and next_permutation
• Choosing the right container: a practical complexity reference for common operations

Outcome: You can solve problems quickly with the STL, pick containers by their complexity guarantees and avoid pitfalls such as iterator invalidation.

• Complexity analysis: Big-O, Big-Omega and Big-Theta; analyzing loops and recursive functions; estimating feasibility from input constraints
• Sorting and searching: merge sort, quick sort and binary search on the answer
• Two pointers and the sliding-window technique
• Hashing for frequency and lookup problems; prefix sums
• Recursion and backtracking basics: generating subsets and permutations, an introduction to N-Queens
• Bit manipulation: AND, OR and XOR tricks, masks, checking and setting bits, enumerating subsets with bitmasks
• Introduction to competitive programming: reading problem statements and constraints, fast I/O, edge cases and testing; practice platforms such as Codeforces, CodeChef, LeetCode and HackerRank
• Capstone kick-off: requirements, class design and a milestone plan

Outcome: You can recognize standard patterns in unseen problems, estimate complexity before writing code and solve easy-to-medium problems within a time limit.

• Capstone build: a console-based management system in C++ combining OOP, the STL and file persistence; design review, implementation and testing
• Capstone problem set: a timed set of problems covering the whole course
• Code quality: naming, modularity, comments, a warning-free build and simple tests with assert
• Version control essentials: Git basics and publishing your capstone on GitHub
• Pointer and memory interview questions: dangling pointers, const correctness, sizeof traps and output-prediction questions
• OOP interview questions: virtual functions and vtables, abstract classes, the rule of three/five and the diamond problem
• STL interview questions: vector versus list, map versus unordered_map, iterator invalidation and operation complexity
• Interview-style practice: explaining your approach aloud, handling follow-up questions and presenting projects on your resume
• Course revision, capstone presentation and evaluation

Outcome: You complete and present your capstone, finish the final problem set and go into interviews prepared for the C and C++ questions that commonly come up.