The C++20 Masterclass : From Fundamentals to Advanced

Set up a Windows development environment for the C++20 masterclass with Visual Studio IDE and CMake, with optional Qt Creator. Learn to install, build, run, and debug projects.

Learn to set up a C++ dev environment on Linux or macOS using Qt Creator, build with CMake, run and debug, and manage multiple files with CMake and include paths.

Explore online compilers like onebox.org, compiler explorer, and brew to test C++20 code across gcc and clang versions, compile, run, view output, and share runnable links.

Establish a cross-platform file structure with starter files for the diving in chapter, enabling C++20 work in Visual Studio on Windows or Qtcreator on Mac and Linux.

Create your first C++20 program in Visual Studio Code using iostream and std::cout to print Hello World with std::endl, build with GCC, and learn that main is the entry point.

Master how to use single-line and block comments in C++ to document code. See how comments are ignored by the compiler and why block comments cannot be nested.

Explore compile time errors, runtime errors, and warnings in C++ and learn how the compiler enforces rules to produce an executable, with examples like missing semicolons and division by zero.

Learn how C++ statements are the units of computation, end with semicolons, and execute top to bottom in main. Discover reusable functions with inputs and return values to perform tasks.

Explore data input and output in C++20 by using streams with std::cout and std::cin, including getline for spaces and simple data greetings.

Explore the C++ execution model and the memory model of a simple program, showing how the binary is loaded into memory, variables are allocated, and a function call flows.

Clarify the differences between core C++ language features, standard library features, and the STL, noting core features as foundations and the standard library as ready-to-use tools like containers and iterators.

Create a reusable Visual Studio Code project template and starter files, then build a first C++ program with include, main, comments, and std::cout and std::cin.

Explore variables and data types in C++, including double, float, char, bool, void, and auto, and learn how memory uses bits and bytes and number systems binary, octal, and hexadecimal.

Discover decimal, binary, hexadecimal, and octal number systems and how computers store data in memory. Learn to represent numbers in C++20 with 0, 0x, and 0b prefixes.

Learn how integers are stored in memory in C++, usually four bytes, and how to safely initialize int variables using brace, functional, or assignment initialization, with size checks via sizeof.

Explore integer modifiers such as signed, unsigned, short, and long, and see how they affect four-byte memory usage and value ranges for int types with practical examples.

Explore floating point numbers in C++, understand float, double, and long double, their memory sizes, and precision; learn about scientific notation, suffixes f and l, and handling infinity and NaN.

Explore how booleans in C++ store true or false to drive decisions with if statements and how they print, memory usage, and examples like red light and green light.

Explore characters in c++ with the char type and ascii encoding. See that a char fits in one byte, prints with std::cout, and can be cast to int with static_cast.

Use the auto keyword in C++ to have the compiler deduce variable types from initializers. Explore suffixes like f, L, u, and ll to see how types are inferred.

Explore assignments that let you reassign values after initialization for integers, doubles, and booleans, and note auto type deduction can cause negative inputs to garble unsigned vars.

Recap chapter on variables and data types, including integers, floats, booleans, and auto. Examine memory as zeros and ones and number systems like binary, octal, hexadecimal in Visual Studio Code.

Explore core data operations in C++, performing add, subtract, and divide on variables, and learn how to format output with std::cout using utilities from the C++ standard library.

Explore basic operations in c++20: addition, subtraction, multiplication, division, and modulus on integers. Practice with a template project in Visual Studio Code to print results.

Explore precedence and associativity in C++ expressions, including left-to-right and right-to-left rules, shown with multiplication, division, addition, and subtraction; use parentheses to clarify intent.

Explore prefix and postfix increment and decrement operators in C++: learn how postfix prints the current value before incrementing, while prefix updates the value before use.

Learn compound assignment operators in c++ by applying +=, -=, *=, /=, and %= to update a value and observe outputs such as 50, 45, 90, 30, and 8.

Learn how C++ relational operators compare integers using <, <=, >, >=, ==, and !=, print booleans, and handle precedence with parentheses in GCC and Visual Studio Code.

Explore logical operators in C++ including and, or, and not, with boolean operands, truth tables, and operator precedence; practice using cout to display true or false and combining relational operators.

Explore output formatting in C++ using iostream and iomanip to format tables, control width and fill, and apply booleans, bases, and floating-point styles with manipulators like std::endl and std::flush.

Explore the numeric limits library to determine the minimum, maximum, and lowest values for floating point and integral types across short, unsigned short, int, and long.

Discover how to use the C math library (cmath) functions such as std::floor, std::ceil, std::abs, trig functions, exp, log, pow, sqrt, and std::round to perform math operations in C++.

Explore how weird integral types behave: sub-four-byte types cannot perform arithmetic, and the compiler promotes them to int during calculations, with sizes shown for short and char.

Explore arithmetic operations, modulus, precedence, and associativity, then prefix and postfix increments, and compound assignments. Examine output formatting with stdcout, numeric limits, math functions, and integral type size constraints.

Explore literals, data stored directly in memory, and master the keywords const, constexpr, and constant, including how compile-time and runtime evaluation work.

Explore how literals are burned into the program binary, how prefixes and suffixes specify literal types, and how to safely initialize unsigned, long, hexadecimal, octal, and binary values.

Discover how const in C++ protects the variable name from modification after initialization, triggering compiler errors for reassignment. Apply const across types and computations to guarantee read-only values.

Learn how constant expressions are evaluated at compile time using constexpr, move heavy computations to compile time, and validate with static_assert to ensure compile-time constraints.

Explore the constant keyword introduced in C++20 and its compile-time initialization for static or thread storage duration. Learn how it differs from const and constexpr.

Explore literals and constants in C++, learn how prefixes and suffixes clarify types, and compare constexpr, constant, and static_assert for compile-time checks.

Explore implicit conversions, overflow and underflow in C++20, and how expressions handle mixed data types. Learn how common types are chosen and how explicit conversions influence results.

Examine how the compiler applies implicit data conversions when mixing int and double, promoting smaller types to larger ones, and how assignment can cause narrowing from right to left.

Explore explicit data conversions, using static_cast to convert between types, compare with old-style C casts, and see when to override implicit conversions in C++.

Explore how overflow and underflow occur with unsigned 8-bit values from 0 to 255, like 130 plus 131 wrapping to 61, and how static_cast helps display the results.

Explore data conversions across variable types in expressions, understand implicit and explicit conversions with static casts, recognize overflow and underflow, and anticipate bitwise operators.

Explore bitwise operators that manipulate integer bits, perform shifts and masks, and logical operations in C++. Learn to print binary representations to visualize bit movement for low-level hardware tasks.

Print integers in binary using the standard library bitset, including its header, and demonstrate 16 bits of unsigned data displayed in binary with cout and show base.

Learn how shift operators move bits left or right, pad with zeros, and permanently lose bits, so reverse shifts cannot recover data; apply explicit casts and bitset printing in C++.

Learn how bitwise logical operators work on bits, including and, or, not, and xor, with practical C++ examples using unsigned chars and std::bitset.

Explore compound bitwise assignment operators in C++ that update a variable in place, including left and right shifts, or, and, xor, with hands-on GCC examples.

Explore how masks highlight or shadow bits within a byte, using bitwise operations (or, and, not, xor) to set, reset, toggle, and check individual or multiple bits in C++.

Use masks to pass options with an unsigned char, replacing eight boolean parameters with bit fields. Apply bitwise checks to read bits and see how the technique appears in OpenGL.

Demonstrate packing color information into a four-byte int using masks and shifts to store red, green, blue, and alpha components, then print values in hex or decimal.

Explore bitwise operators in C++20, shift bits left or right, apply and, or, not, and compound assignments, use masks to set, reset, check, and toggle bits, with real-life examples.

Understand variable lifetime in the C++20 masterclass by examining storage duration: local, static, and dynamic, and when each variable dies.

Explore variable scope in the C++20 masterclass, distinguishing global and local variables, nested scopes, and compiler errors when using names outside their scope.