C++23 Fundamentals with Projects & Algorithms

Set up a cross-platform C++ environment across Windows, Linux, and macOS with Docker and Visual Studio Code. Use online compilers and learn basic project structure.

Set up a modern Windows C++ development environment by installing Visual Studio, CL compiler, CMake, Ninja, VC package, Git, and Visual Studio Code, then configure environment variables and workflows.

set up a modern c++ development environment on linux (ubuntu 24.04) with clang, cmake, ninja, and vcpkg, and configure vscode for productive editing and building.

Set up a modern mac development environment for C++ using Apple clang, with optional Docker, and install CMake, VC package, Ninja, and Visual Studio Code to streamline building and debugging.

Docker provides a ready-made Linux environment with modern C++ tools like GCC/clang and CMake, enabling you to develop, run, and debug from Visual Studio Code without altering your local setup.

Explore compiler explorer to run C++ code in a browser, compare GCC, Clang, and Visual C++ online, and inspect assembly and resulting binary code.

Explore the C++ project structure, including CMakeLists.txt, presets, modules, main.cpp, and dependencies like fmt, built across Windows, Linux, and macOS with VC package.

Learn to manage versions with git in Visual Studio Code, initializing repositories and pushing to GitHub. Handle gitignore, staging, commits, branches, and diffs to track changes and revert when needed.

Learn to set up and use the Visual Studio IDE on Windows, including installing Visual Studio, CMake, and Ninja VC package, then build and debug from a folder.

This lecture guides you through your first C++ program, main as the entry point, printing with fmt, and basic debugging with cmake, vc package, and modules.

Explore the C++ program execution model from code writing to compilation, loading into memory, and CPU execution, including function calls, variables, and binary output.

Learn to set up SFML in a C++20 project with CMake and VC package, linking graphics and window modules to build a simple graphical user interface window.

Learn to build a CMake project manually on the terminal, both with and without presets, using VC package, a CMake toolchain file, and baselines to manage dependencies.

Build a CMake project on the terminal with cmake presets across Windows and Linux, then configure, build with ninja, and run the rocket binary.

Discover how variables are stored in memory and C++ data types like integers and floats. Explore binary, decimal, hexadecimal, and octal number systems and ranges that govern precision.

Explore variables and data types in c++23, including integer representations in decimal, octal, hexadecimal, and binary. Learn floating point types, precision, and memory, printing with fmt and std numeric limits.

Explore safe and common initialization in C++, covering braced initialization, functional initialization, and assignment initialization, including zero initialization, using expressions, avoiding narrowing conversions, and introducing the auto type.

Explore C++ integer modifiers—signed, unsigned, short, long, and long long—and their memory sizes; then examine floating-point numbers, fixed and scientific notation, and the concepts of infinity and NaN.

Explore booleans and bool type, using true and false to drive if statements with red and green lights, and print with the FMT library; then cover chars and ascii codes.

Explore collections in C++ by using stdvector, stdarray, and stdstring to group data, learn dynamic vs fixed containers, and see auto deduce types with practical examples.

Cover core C++ operations on numbers, including arithmetic, modulus, and conversions, with hands-on Visual Studio Code examples; master operator precedence, associativity, parentheses grouping, and prefix/postfix and compound assignments.

Explore using C++ logical and relational operators (and, or, not) with booleans and truth tables, plus math functions (floor, ceil, abs, round, exp, pow, log, log10, sqrt).

Explore how small integer types like short int and char promote to int in arithmetic, and how implicit and explicit conversions, overflow, and underflow shape C++ expressions.

Explore bitwise operators part 1 in C++, including printing 16-bit integers in binary, shifting left or right, and applying logical, compound, and mask operations.

Explore masks and bitwise operators to set, reset, check, and toggle bits using or, and, xor, and shifts in C++.

Demonstrate practical use of bitwise and shift operators with masks to pack color information into an integer and simplify configuration flags with a single byte parameter.

Explores core C++ fundamentals—data types, variables, initialization, and operators—then refactors an SFML GUI app to store window dimensions, title, color, and background in variables for maintainability.

Master input and output in modern c++ using std::cout, std::cin, and getline, with formatting options like set width, set fill, boolalpha, hex, fixed, scientific, precision, and showpos.

Explore the C++20 formatting library and its evolution in C++23, compare std::format and the fmt library, and learn to format data with placeholders, width, alignment, and dynamic widths.

Explore literals and constants in modern C++ and how constexpr enables compile-time evaluation. Identify integer, floating point, character, string, and boolean literals, including unsigned, long, and binary, hex, octal forms.

Explore constants in C++ by using the const keyword to initialize once and prevent modification. Learn safe defaults, braced literals, and compile-time errors when attempting to change constants.

Master constexpr variables for compile-time evaluation in modern C++. Learn declaration, const correctness, and limits, including runtime versus compile-time initialization and static_assert checks.

Learn how constexpr functions in C++23 enable compile-time evaluation when given constexpr parameters, and how runtime variables shift computation to runtime, demonstrated with an add function and literals.

Constable functions are like constexpr functions but forbid runtime evaluation, guaranteeing compile-time computation or a compiler error. If inputs aren't compile-time constants, code won't compile, illustrating the strict compile-time requirement.

Explain the constinit and constant keywords in modern C++20, emphasizing global scope initialization, compile-time guarantees, and the distinction from runtime initialization using literals and constexpr.

Tackle an SFML-based challenge to apply constants and constexpr, handle events, and respond to keyboard input while iterating with documentation and basic iostream output.

Explore C++ flow control with if statements, switch cases, and the ternary operator, and learn how initializers, else if chains, and short-circuit evaluation shape program decisions.

Explore loops in C++23, including for, while, and do while, with four-component logic (initializer, end condition, incrementation, body), debugging in Visual Studio Code, vector usage, range-based loops, and break/continue strategies.

practice c++ flow control and sfml event handling in a challenge project, using if, switch, loops, and key, mouse, and clock-based updates to drive interactive graphics.

Explore std::array, a fixed-size container in C++, learn to declare, initialize, access with [ ] or at(), iterate with range-based loops, and build one-dimensional and two-dimensional arrays with bounds checking.

Explore std::vector as a dynamic, heap-allocated alternative to std::array, detailing its API, differences from fixed-size std::array, and how to use push_back, size, front, back, and range-based loops.

Explore stdstring as a dynamic collection of characters and compare it to stdvector and stdarray, then declare, access, append, substring, and manipulate strings with familiar operations.

Explore built-in row arrays in C++: declaration, initialization, memory layout, and safe iteration, plus common pitfalls like out-of-bounds access and differences with std::vector and std::array.

Explore random numbers in C++ by comparing the old std rand approach with seeding and range control, and the modern C++ facilities using random_device, Mersenne Twister, and uniform distribution.

Builds a fortune teller app using a vector of strings for predictions, and modern c++ random facilities—random device, mersenne twister, and uniform distribution—to select forecasts.

Master C++23 fundamentals by building a SFML application that stores multiple circle shapes in a std::vector, initializing varied radii and positions, and controlling color and size with keyboard input.

Track the last five key presses using a fixed-size std::array and a circular index, printing history to the console with modulus-based wrapping in c++23.

Cycle through a predefined color sequence stored in a static array with the space key, wrapping via modulus and applying the current color to shapes in an SFML window.

Animate bouncing balls with sfml using a vector of shapes and directions. Update positions on a shared timer and bounce off edges.

Learn to draw random colored shapes in an sfml window by left-clicking to add and right-clicking to remove, while managing shapes with a vector and handling event processing and rendering.

Explore pointers in C++, learn how int and double pointers hold addresses, how to assign and dereference them, and how stack and heap memory layout affects access.

Explore how to combine pointers and const in c++. Learn pointer types, including non-const pointers, pointers to const, const data, and const pointers, with practical examples.

Explore the relationship between pointers and arrays, treating the array name as a pointer to the first element, printing addresses, and note that the array name cannot be reassigned.

Navigate arrays with pointer arithmetic to reach elements, measure distances in element units, and learn to compare pointers and print addresses and values.

Explore dynamic memory allocation in C++ by using the stack and heap, with new and delete, while initializing pointers to nullptr and considering safe options like std::vector.

Explore dangling pointers and memory management in dynamic allocation by initializing pointers, resetting after delete, and using a master pointer to avoid leaks, while handling new failures with exceptions.

Learn how smart pointers manage dynamic memory in c++, focusing on unique pointers that own memory, release it automatically, and support safe ownership transfer.

Explore how shared pointers manage heap memory with reference counting, enabling multiple pointers to share the same object and release memory when count reaches zero via copy, reset, and make_shared.

Explore references in c++: declare and initialize references, compare with pointers, use const references, and apply references to range-based for loops, revealing memory addresses and stack variables.

Revisit the sfml based dynamic memory challenge, exploring raw pointers and heap memory, then compare std::vector with smart pointers via make_unique and manual new/delete across three approaches.

Explore building a terminal-based user interface in C++ using the FDX UI library, including VBox layouts, text elements, and interactive buttons, as you tackle challenge 2.

Learn to handle characters and c strings in c++23 fundamentals. Use cc type header facilities to test alphanumeric, alphabetic, blank, lower, upper, and digit, and apply strlen and strcmp.

Master std::string fundamentals, including initialization, modification, and concatenation, then explore string literals and the s suffix, to_string, and raw string literals for clean, modern c++ text.

Learn how string view provides a cheap, non-owning view of string data, avoiding copies, and enabling initialization, viewing, and windowing (prefix/suffix) with lifetime considerations in C++.

Delve into four string and character challenges: analyze text counts of uppercase, lowercase, digits, and punctuation; copy strings with C strings and dynamic memory; reverse words; and check palindromes.

Build a palindrome checker UI with the FTX UI library, replacing terminal interface with a graphical input and dynamic result display that colors output green for palindromes and red otherwise.

Learn the basics of C++ functions: define return type, name, and parameters, call and return values, and organize code with declarations, definitions, and modules.

Explore function parameters in C++23, contrasting pass by value, pass by reference, and pass by pointer, with const and default parameter variations.

Learn how to pass sequence data as function parameters in C++ using arrays and pointers, with 1d, 2d, and 3d examples. Explore safer alternatives with std::array and std::vector.

Explore constexpr and consteval functions in C++ to run at compile time or runtime. See how compile-time computations bake results into the binary, shifting cost from runtime to compilation.

Explore how to pass and process command-line arguments in C++ using argc and argv, loop through inputs, and build a calculator example with utilities for argument handling.

Explore function overloading in C++, using the same name for functions with different parameter types or counts, with practical examples like print overloads and std getline.

Explore lambda functions in C++23, learning anonymous functions, capture lists, parameters, returns, and by-value vs by-reference captures, with practical examples in Visual Studio Code.

Explore C++23 attributes and static variables inside functions, then dive into recursion with fibonacci and memoization, including a lambda approach with explicit object parameters.

Break down an sfml application into initialization, event processing, and rendering functions, using cmake and vc package to link sfml and build a clean, modular app.

Build an ftx ui based calculator in c++, using lambda functions and input fields. Choose add, subtract, multiply, or divide with a menu and see the result.