Explore how C++ extends C with function overloading and default arguments, enabling same-name functions with different parameters. Learn flexible variable declarations, block scope, and forward declarations that streamline programming.

Explains operator overloading in C++ via a complex number class, showing how to overload operators for custom types, including stream operators, with by-reference parameters and returns.

Learn console input and output in C++ using streams, read numbers and strings with the string class, and manage input buffers with getline and ignore for robust input.

Explore encapsulation in C++ by modeling a class as a collection of data members and member functions with private and public access, this pointer, and object lifetime.

Explore static data members in a C++ class: a single shared memory copy across all instances, auto-initialized, lasting the program, and enabling object counting with access via the class name.

Implement a singleton class in C++ with a private constructor and a static getInstance to create a single object and manage its lifetime.

Master how friend functions and friend classes in C++ access private data, balancing encapsulation and data abstraction with performance. Explore forward declarations, scope resolution, and nonmember access patterns.

Explore how base and derived constructors allocate memory for all members, with base-first constructor execution, and how to pass base arguments for proper initialization.

Explore single, multiple, hierarchical, multi level, and hybrid inheritance in C++, where derived classes inherit properties and methods from base classes. Understand how hybrid inheritance introduces complexity and potential duplication.

Learn upcasting and downcasting in c++, using implicit base-pointer assignments and explicit derived casts, with static_cast vs dynamic_cast for safety.

Explore the differences between function overloading and overriding, how virtual and non-virtual methods bind at runtime or compile time, and how destructors behave in base and derived classes.

Explore runtime polymorphism in C++ by using a common figure base class with pure virtual functions, forcing derived circle and square to override area and perimeter, enabling dynamic binding.

Understand streams in c++, distinguish text and binary streams, and learn how standard input/output and files operate, with encoding considerations and basic error handling.

Explore the C++ io stream hierarchy, from the basic input/output stream base to istream and ostream, and learn how the standard library enables input and output operations.

Master file handling in C++ by creating, opening, and closing files with proper extensions. Perform read, write, and append operations, and manage buffers and seek positions.

Master binary file input/output in C++ by writing and reading data in binary format with stream operations, handling objects and primitives, and managing read/write pointers.

Save and load objects in a binary file by writing fixed-size records as a byte array with C++ file streams, then read them back in the same order.

Learn to detect and handle file handling errors in C++, distinguishing end of file, bad, and fail states with API checks, error descriptions, and guidance on recoverable versus fatal errors.

Learn text input and output operations using C++ streams, opening and closing file streams, reading from keyboard with cin, writing to console or files, and handling end-of-file.

Explore how C++ handles runtime errors with exceptions, using try catch blocks and throw statements, including synchronous exceptions and predefined and custom exception classes, and how stack unwinding propagates errors.

Explore how to use try, catch, and throw to handle division by zero by designing a math class with numerator and denominator and throwing or catching exceptions.

Learn to design a custom exception class in C++, including constructors, destructor, and copy semantics; explore throwing by value versus pointer and memory management, with an Employee example.

Understand how stack unwinding propagates exceptions in C++ by destroying automatic objects in reverse order. Observe how the copy constructor runs and control transfers to the matching catch block.

Templates in C++ form the foundation of genetic programming, enabling code to be type independent with function and class templates. Compile-time type safety verifies templates work with types when instantiated.

Explore class templates in C++ by building a generic complex class with real and imaginary parts, using template parameters to support multiple data types and operator overloading.