Learn C++ from scratch to production-grade across 24 episodes: pre-requisite skills & environment setup, background history & why you need C++, core concepts & main architecture, basic syntax & program structure, control flow & operators, functions & modular programming, object-oriented programming, memory & resource management, data structures & STL containers, input/output & file handling, templates & generic programming, error handling & debugging, concurrency & multithreading, networking basics, secure coding & safety, performance & optimization, modern C++ features, architecture & design patterns, system programming & low-level integration, modern tooling & build automation, cross-platform development, embedded & high-performance systems, observability & production support, through to stable modern features & future trends, in a total of 24 episodes.
This opening episode makes sure you're ready to learn C++. You will understand the basic skills you must master, set up the GCC compiler, the CMake and Ninja build tools, the GDB debugger, an editor, and verify the environment with your first program.

This episode traces the history of C++ from the birth of C with Classes by Bjarne Stroustrup, the standardization journey from C++98 to C++23, C++'s role in operating systems and game engines, to the problems it solves compared to traditional approaches.

This episode dissects how C++ works behind the scenes: the compilation process from preprocessing to linking, the stack and heap memory model, ABI and name mangling, program structure with header and source files, and build workflows with CMake.

This episode builds your C++ basic syntax: complete program structure, variable and constant declarations with fundamental types, functions with scope and return values, and an interactive program using std::cin and std::cout.

This episode covers arithmetic, logical, bitwise, and incremental operators, the if, switch, and ternary conditional statements, all kinds of loops from for to range-based for, and the use of break and continue to control program flow.

This episode dissects functions thoroughly: declarations versus definitions, overloading, default arguments, inline and constexpr, splitting headers and sources with linkage, as well as function pointers, lambdas, and std::function for treating functions as values.

This episode covers object-oriented programming in C++: classes and objects, constructors and destructors, access specifiers and encapsulation, inheritance and polymorphism with virtual functions, abstract classes and the interface pattern, as well as smart pointers.

This episode dissects pointers and references, pointer arithmetic, dynamic allocation with new and delete along with smart pointers, the RAII pattern for deterministic resource management, and common memory bugs like use-after-free and double-free.

This episode introduces the Standard Template Library: sequence containers like vector, array, and deque, associative containers like set, map, and unordered_map, iterators along with std::algorithm algorithms, and the stack, queue, and priority_queue container adaptors.

This episode covers the basic std::istream and std::ostream streams, file I/O with std::ifstream, std::ofstream, and std::fstream, formatted input output with manipulators, binary I/O, as well as error handling and checking whether a file exists.
