Complete C++20 Visual and Practical Course: Zero to Mastery

Trace the history of C++ from C with classes to modern C++20, noting 11, 14, 17, and 20 updates and core concepts like object-oriented programming and smart pointers.

explore the evolution of modern C++, from C++11 to 20, highlighting modules and three-year library updates, and show wide use in gaming, VR, AR, AI, Unreal Engine, and Vision Pro.

Explore how the C++ standard library speeds development, reduces errors, and delivers pre-built functions, iterators, and algorithms for gaming and other applications.

Begin coding in cpp20 in the complete visual and practical course by writing a main function, including iostream, and using std::cout and std::cin in a .cpp file.

Learn how functions in C++ work, including the main function, function signature, arguments, and return type; discover how breaking programs into small, focused functions improves reuse, testing, and debugging.

Learn how console applications use input and output streams in c++ to communicate with users, using std::cout and std::cin with insertion and extraction operators to read and display data.

Explore how the return statement enables function communication by returning values and enabling early exits, especially in main where zero signals success, with the compiler adding a return if omitted.

Understand how namespaces prevent naming collisions by fully qualifying identifiers with a scope resolution operator, such as std::add versus mynamespace::add. Use real-world family names to grasp the concept.

Explore the difference between names and keywords in C++, and how to use valid names with case sensitivity, underscores, and digits while avoiding reserved keywords.

Diagnose and fix errors by following language rules, tackling syntax, semantic, linker, and runtime issues through debugging, while heeding warnings like unused or uninitialized variables.

Explore how variables serve as memory containers with data types like int, short, unsigned int, float, double, char, and bool, from declaration to initialization, including naming and C++20 brace initialization.

Explore signed and unsigned integers in c++, learning how short, int, long, and long long differ in size and range, and why memory considerations guide type selection.

Explore integers through addition, subtraction, multiplication, division, and modulus; learn binary, unary, and ternary operators, assignment and operator precedence, with compound expressions and dynamic input in a C++ program.

Master increment and decrement operators in C++ by understanding unary behavior, postfix versus prefix, and how they return or modify a variable's value in loops and games.

Explore the size of operator in C++20, learn how it determines memory size for built-in and user-defined types, and use it for memory management and compile-time checks.

Practice building a real life C++ project in Visual Studio Code, calculating quantity, price, subtotal, sales tax, and total cost while addressing integer versus floating point issues.

Build a simple C++20 sales tax calculator that takes quantity and price, computes subtotal, tax, and total cost, while illustrating type handling and percentage calculation.

Explore implicit and explicit conversions in C++20, including using static_cast to prevent data loss when converting between int and double. Learn about truncation and rounding with std::round from math header.

Learn to store a single character with char and its wide and utf variants, using single quotes and prefixes like L and U8, and print with wcout.

Explore strings in C++ as a class container of characters, learn formatting with string manipulators and std format to print and format names, numbers, and text.

Explore the auto keyword in C++20, learning how the compiler deduces a variable's type from its initializer, with practical examples such as int, string, double for pi, and char.

Explore how variable lifetime and scope determine when variables exist and can be accessed, covering automatic, static, and dynamic storage, and global versus local visibility.

Discover how the size of operator reports a variable’s storage in bytes, and use limits to fetch min and max values for short, int, long, long long, float, and char.

Declare three integers, read them from the user, and compute their sum in double with static_cast, then calculate the average by dividing by 3.0 and display the sum and average.

Explore how arithmetic operators in c++20 add, subtract, multiply, divide, and modulus work on numeric data types, and learn operator precedence with parentheses and remainders via pemdas.

Explore how assignment operators in C++ modify variables, including add-assign, subtract-assign, multiply-assign, divide-assign, modulo-assign, and bitwise and, or, xor, and left-shift-assign, with practical examples.

Learn how relational operators compare two values and return boolean true/false results in C++20. See examples of equal to, not equal, less than, greater than, and their combinations in code.

Explore the spaceship operator in C++20, a three-way comparison that returns minus one, zero, or one, and use auto to capture its strong ordering results.

Explore how logical operators in C++20 work with booleans, including and, or, and not, through practical bank, gaming, and condition examples, with emphasis on parentheses and precedence.

Learn bitwise operators in C++, including and, or, xor, not, left and right shifts, and use masks on unsigned short to pack and extract RGB color and font attributes.

Review increment and decrement operators as unary operations that increase or decrease a variable by one, including pre- and post-increment forms, and their use with integers, pointers, and floating point variables.

Learn how the conditional (ternary) operator replaces simple if statements to choose between two results, use three operands, and compute the greater value in C++20.

Explore how the comma operator combines multiple expressions in a single statement, evaluates left to right, and is a binary operator with the lowest precedence among C++ operators.

Master operator precedence in C++20 by using parentheses to control evaluation, understanding left-to-right rules for arithmetic and right-to-left for assignment and conditional operators, with practical code examples.

Practice projectile motion in c++20 by declaring doubles for velocity, angle, time, and height; convert angle to radians and compute distance, velocity components, and height using sine, cosine, and gravity.

Master C++20 basics by declaring and initializing variables, converting angles to radians, and computing distance, velocity components, height, and gravity with sine and cosine from the standard library.

Master the boolean data type in C++20, learn how true and false map to 1 and 0, and use comparison, logical operators, and the spaceship operator for three-way results.

Explore how if statements control program flow with true or false conditions, use else, else if, and nested if, and explain the dangling else problem.

Learn how else if chains handle multiple conditions, assign grades based on score thresholds (90, 80, 70, 60), and why nested ifs are needed.

Explore nested if statements in c++20 by validating age, checking the driving test with y or n, and handling invalid input to decide driving eligibility.

Master switch statements in C++: dispatch code blocks by matching a value to cases, use break and optional default, and understand fall-through with integers, chars, and enumerated types.

Explore how loops repeat code under a condition using for, while, and do while variants. Master iterations, increments, and how to handle infinite loops.

Learn how a while loop operates when iterations are unknown, with condition checked before each run and examples like counting and menu input.

Discover how the do-while loop executes its body at least once, unlike a while loop. Use it to display a menu and collect user input until checkout.

Discover how the for loop works in c++20, with initialization, condition, and increment, and learn to apply it when the number of iterations is known, via a total cost example.

Learn how to use the range based for loop to iterate over containers like strings, arrays, and vectors, and apply per-element operations such as uppercase conversion.

Explore continue and break statements to control loop flow, skipping iterations and exiting loops in for and while constructs, including handling infinite loops and practical examples.

Build a simple bank management console app using C++20, implementing a menu-driven loop with switch cases to deposit, withdraw, check balance, and exit.

Build a bank management system in C++20 that runs an infinite loop, shows a deposit, withdraw, and balance menu, updates balance via switch, and formats the balance to two decimals.

Explore arrays as fixed-size containers of the same data type stored contiguously in memory, with access starting at index zero, and use the size operator to determine their memory footprint.

Learn to work with array elements in c++, using zero-based indexing, initializing arrays, and safely accessing values while understanding memory location implications and out-of-bounds risks.

Explore multidimensional arrays in C++, declaring 2d arrays with extra brackets for rows and columns. Access, initialize, and print elements using zero-based indices with std::cout, noting sizes and unchecked bounds.

Master std::array, a fixed-size container from the standard library. Learn its bound checking, initialization, and handy member functions like fill, at, size, begin, end, and swap.

Discover vectors in C++ std as dynamic containers that resize at runtime, unlike arrays, and learn pushback, size, front, back, and vector of vectors.

Explore vectors in c++, using a vector of vectors to form a matrix structure with resizing and access via [i][j] or at. Learn vector of arrays and arrays of vectors.

Explore characters in c using the c type library to check isalpha, isdigit, islower, isupper, isspace, and punctuation, and convert between cases with lowercase and uppercase conversion functions, including header.

Explore c-style strings, arrays of characters terminated by a null character, and functions like strlen and strcpy. See how getline handles spaces for both std::string and c-style strings.

Learn how C++ strings differ from C-style strings, using std::string for dynamic resizing and memory management, with common methods like length, size, find, and getline.

Build a quiz game in C++20 by declaring vectors of questions and answers, a vector of arrays of strings for choices, and implement scoring and user input.

Implement and run a C++20 quiz game by using vectors of strings, arrays for four choices, and a score-tracking loop, including pushing new questions and answers.

Functions organize code into modular, reusable blocks that hide complexity through abstraction, using parameters, return types, and signatures, and are called from main to create maintainable programs.

Learn to call functions inside main, pass parameters, handle return values, and print result, including nested calls and standard library functions like sqrt, min, and max.

Learn how function prototypes declare a function's return type and parameters before main, enabling calls to functions defined later or in separate files while maintaining clear abstraction.

Explain how function parameters and return types enable passing values between functions, including pass by value, scope, and return values, with auto return type deduction and prototype rules.

Distinguish parameters from arguments and grasp prototypes versus definitions. Use default arguments to make parameters optional, position defaults at the end, and call with or without values.

Pass arrays to functions by address, not by value. Treat the array name as the address of the first element, and manage size, const qualifiers, and multi-dimensional arrays.

learn how to pass arguments to the main function in the complete c++20 visual and practical course: zero to mastery, using argc and argv.

Discover how static variables inside a function are created on first call via the static keyword and persist for the program’s lifetime, carrying values between calls.

Explore how function overloading lets multiple functions share the same name with different parameter lists or types, enabling int, double, float, and long long additions.

Explore recursion by learning how a function calls itself, directly or indirectly, and compare it with loops, using factorial as a guiding example and noting memory risks.

Learn how function calls use the stack to save return addresses and manage local, global, and static variables, illustrated by a recursive factorial example and memory layout.

Learn how inline keywords expand small functions at compile time. The lecture contrasts runtime call overhead with compile-time expansion in an addition example.

Learn to build a simple encryption-decryption app in C++20, using encryption and decryption keys, functions, and a user-driven menu to encrypt and decrypt messages.

Build a simple encryption app using const encryption and decryption keys, string functions encrypt_message and decrypt_message, and a menu to encrypt, decrypt, or quit.

Discover how pointers store the address of variables and how to declare them. Use the address-of operator, access values indirectly, and understand null pointers.

Master dereferencing pointers by using the asterisk, the indirect operator, to access and modify values at memory locations, print values and addresses, and understand how pointers can point to variables.

Explore array of pointers and pointers to arrays in C++20, learn how to create and access pointers, dereference them, and navigate memory addresses with pointer arithmetic.

Understand constant pointers and pointers to constants in c++. Learn how a pointer's address can be fixed while the pointed value remains modifiable, and how both can be restricted.

Master pointer arithmetic by applying addition, subtraction, and increment and decrement to navigate memory by elements, not bytes, and use dereference and array traversal to access elements.

Explore dynamic memory allocation in C++, using new and delete to manage heap storage, allocate dynamic arrays, and handle pointers, nullptr, and risks like memory leaks and dangling pointers.

Explore hazards of dynamic memory allocation in C++, including memory leaks, dangling pointers, and fragmentation, and learn safe use of new and delete to avoid memory leaks.

Explore hazards of dynamic memory allocation with real examples, including memory leaks, dangling pointers, and multiple deallocation. Learn safe practices and how to prepare for smart pointers.

Explore smart pointers in C++11 for dynamic memory management, using unique_ptr, shared_ptr, and weak_ptr to prevent leaks and dangling pointers.

Discover how shared pointers manage memory with reference counting, use_count, and make_shared, compare with unique pointers, and learn about weak pointers and cyclic reference issues in C++20.

Explore creating smart pointers to containers such as arrays and vectors, using shared_ptr and unique_ptr with practical examples of initialization, access, and methods like get, release, reset, and use_count.

Explore how references act as aliases for existing objects, enabling pass-by-reference and avoiding copies in functions and range-based loops.

Learn how to pass pointers to functions in C++, use the address-of operator to pass a variable, and dereference to modify the original value.

Explore how a function on the left side of an assignment can return a reference to the larger of two numbers, with const qualifiers and reference assignment.

Explore input and output parameters in C++20, learn when to pass by value, const reference, or by non-const reference, and see how references and pointers enable modifying original data.

Review how to pass arrays to functions using the array name as the address of the first element, and by pointers or references with size and multi-dimensional arrays.

Develop an interactive inventory system with add, display, and sell tasks. Learn to manage names, prices, and quantities with unique pointers and basic move semantics.

Master a C++20 inventory system by implementing add, display, and sell functions using vectors of unique pointers, move semantics, and a console interface to manage products.

Define and use enumerated data types to create user defined types with readable names and fixed values. Compare unscoped vs scoped enums (enum class/enum struct), underlying types, and switch usage.

Learn to create your own data types with enums in C++20, including unscoped and scoped (class) enums, assign values, and use them in switch statements with days of the week.

Explore the unlimited universe of object oriented programming as classes serve as blueprints to create reusable objects with methods and members that define behavior.

Encapsulation organizes data inside a class by separating private data from public access. It uses setters to control changes, hides complexity, and enables data protection, information hiding, and modular code.

Explore how structs in C++20 mirror classes but with public default access, enabling lightweight data structures. Learn struct syntax, initialization, and when to choose struct versus class.

Learn to declare member methods inside a class and implement them outside using scope resolution, illustrated by a game player example with public methods and a private variable.

Explore how constructors initialize class objects and how destructors clean up resources, including memory allocation and scope-based destruction, with overloads, default behavior, and practical examples.

Explore how default constructors interact with parameterized constructors in C++, including overloading, compiler-generated defaults, and default initialization using = default.

Learn how constructor overloading lets a class offer multiple initialization options through different parameter lists, enabling objects to be created with no info, just a name, or name and age.

Learn how constructor initialization lists in C++20 simplify initializing member variables. See how to use default and parameterized constructors in practical Visual Studio examples.

Apply constructor delegation to centralize initialization, letting one constructor initialize variables while others delegate to it, thus avoiding code duplication with default arguments and initialization lists.

Use constructor default parameter values to replace multiple constructors and initialize members with defaults via the initialization list, avoiding default constructor ambiguity.

Explore how implicit conversions create unintended objects and how the explicit keyword disables implicit constructors. Learn to prevent comparing integers with class objects by requiring explicit conversion.

Explore copy constructors in C++20, including when to copy or assign objects, shallow vs deep copy, compiler-generated vs custom implementations, and how to delete or delegate them.

Explains shallow copy in C++ by duplicating members, shows how copying pointers to dynamic memory can create a shared memory location, leading to dangling pointers when destructors run.

Understand deep copy and why it creates independent memory for objects with raw pointers, contrasting it with shallow copy. Implement a deep copy constructor to allocate memory and avoid sharing.

Move constructors transfer ownership of resources to avoid costly copies for large objects, detailing compiler-generated and explicit move constructors and deleting the copy constructor.

Explore this pointer, its arrow operator, and dereferencing to access current object members and resolve name shadowing. Learn method chaining by returning the current object in calculator, enabling fluent calls.

Explore const with classes in C++20, mastering const objects, const correctness, and const member functions, with the mutable keyword enabling selective modification inside const contexts.

Discover how static class members belong to the class, are accessed without objects via the scope resolution operator, and how inline static and outside class initialization manage class-wide data.

Explore how a friend class gains access to another class's private and protected data. Remember that friendship is not symmetric or transitive and is limited to the declared friend relationship.

Learn how private class members enforce data hiding and encapsulation, and use getters and setters with clear naming to control access and updates to those variables.

Master nested classes in C++20 by learning how an inner class accesses the outer's private members, explores scope and access rules, and practices instantiating a class inside another class.

Learn to build a library system in c++20 by defining book and member classes, a library container with vectors and getters, and a menu-driven interface for display, borrow, and return.