Quick Start to Modern C++ for Programmers [2026 Edition]

Learn signed and unsigned integers across 8 to 64 bits, std int types and suffixes, then cover floats, doubles, booleans, and chars with ascii mapping.

Explore boolean expressions, if statements, and the ternary operator in C++. Learn how true and false, comparison operators, and parentheses shape conditions, with braces or one-line ifs.

Explore for loops over a range with an unsigned int, and pre versus post increment and decrement, then compare while and do while, noting do while runs at least once.

Master function declaration and definition in C++, learn to declare before use, use void for no return value, and explore function overloading and later template concepts.

Learn to split a C++ program into header and source files, create a tiny library, and use include guards and includes to form a translation unit.

Learn to use breakpoints and the debugger in debug builds to inspect local variables, step into functions, and compare debug versus release builds that optimize code for speed.

Explore modern C++ enum class usage to define scoped enum types, compare with classic enums, and handle switch cases and if statements for status values like connected, disconnected, and unknown.

Explore structs as plain old data, initialize and access their members with the dot operator, and cast enum values using static_cast or c-style casts, plus designated initialize lists in C++20.

Explore how the auto keyword enables compile-time type deduction, while uniform initialization prevents implicit conversions and narrowing. Learn when to use static_cast to make conversions explicit.

Explore const and constexpr in modern C++. Identify read-only parameters and variables, and how compile-time evaluation shifts work from runtime to compile time.

Explore how the static keyword creates local static variables that initialize once and persist across the program, enabling counters that track function calls.

Explore namespaces to group related functionalities, using std and user defined namespaces like db with nested types, status, and methods. Learn to qualify names with full namespaces to avoid confusion.

demonstrates how an anonymous namespace or static declarations restrict global functions and variables to the current translation unit, contrasting with header-based access in C++.

Learn how coding exercises are structured in this course, with starting code, exercise descriptions, and solution videos, plus guidance to attempt before watching the solution.

Define an enum class for lane association and a vehicle type struct inside the ad namespaces, then print the ego vehicle data using designated initializers and a const print function.

Learn how to use arrays in modern C++, compare C-style arrays with std::array, and harness templates to handle arrays of any compile-time size while safely initializing and querying their length.

Compare c-style arrays and std::string to manage strings in C++ and understand the null terminator. Learn string literals, compile-time length deduction, and why std::string supports dynamic size and common operations.

Explore memory management in C++, comparing copies and references for function parameters, and learn when to use const or non-const references to avoid copies.

Explore how pointers store memory addresses and how dereferencing changes values, contrast with references, and learn when to use pointers versus references for passing arguments and avoiding copies.

Examine memory layout in C++, from stack to heap, and learn heap allocation with new, dereferencing, and deletion with delete; recognize null pointers and future use of smart pointers.

Define lvalues and rvalues, explain memory address implication, and contrast copy by value, copy by value const, non-const reference, and const reference in parameter passing.

Extend the last exercise by modeling six neighboring vehicles (two per lane) with distance and speed, and implement print functions to visualize the scene around the eagle vehicle.

Create template functions that use a generic type to print to console spans and containers, reducing overloads. Call the template with a type and apply it to vectors and arrays.

Explore std::vector in the standard library as a dynamically sized, contiguous container. Learn initialization, push_back and pop_back, and how to use range-based for loops with begin/end iterators for inserting elements.

Introduce std::span from C++20, a lightweight non-owning view over contiguous memory that works with vectors, arrays, and C-style arrays, enabling range-based access without copying.

Explore std::pair and std::tuple as two-value and multi-value containers, and how to include utility headers. Use structured bindings to name and unpack tuple elements and return tuples from functions.

Explore std::map as a sorted container of key-value pairs, using operator[] to add or update entries and contains or find to check existence.

Learn to define alias types with the modern C++ using keyword, compare it to typedef, and create template aliases for byte vectors and generic vectors.

Explore standard library iterators, including begin/end, reverse_begin/reverse_end, and const iterators, across containers like vector, array, map, and list, with utilities such as advance, distance, next, and previous.

Copy values between containers with the copy function, inserting at a chosen position via an iterator, or append at the end using a back insert and begin and end iterators.

Learn to implement iterator utilities in c++, using advance, distance, next, and previous for vectors; explore iterator aliases, difference types, and handling positive and negative directions safely.

Master std::string basics: initialize from text literals, perform find, rfind, replace, and substrings, check length and emptiness, compare strings, and convert numbers to and from strings with base options.

This lecture explains the small string optimization, which stores short strings in a 15-character stack buffer. It notes a 22 threshold and that string view avoids allocations for read-only parameters.

Learn how to read and write files in modern C++ using fstream, including text and binary modes, with a sample player data struct showing write and read back.

Learn to use std::filesystem to create and manipulate paths, including current path, path separators, existence checks, relative and absolute paths, directory iteration, and copying or creating files across operating systems.

Count word frequencies from a text file in modern c++ by reading, splitting on whitespace into a vector, and updating a map to tally occurrences.

Learn how std::random uses mt19937 to generate numbers, seed the generator, and sample from uniform or normal distributions to fill a vector with 1 million values, printing the first ten.

Explore the Chrono header to time code with time points and steady clock, measure a function's duration in microseconds, milliseconds, or nanoseconds, and cast durations for precise performance insight.

Explore the Chrono library's date and time zone utilities, including calendar types (day, month, year, weekday), duration units (minutes to nanoseconds), and literals, plus converting time points between time zones.

Explore std::numeric_limits in the standard library to learn min, max, epsilon, and precision for integers and floating point types, and understand why equality checks fail for floats.

Explore lambda functions in modern c++, using capture lists and auto parameters to inline algorithm checks. See iota-filling vectors and divisibility tests, and how the compiler creates a class.

learn how to use std::generate to fill a container with values from a generator function or lambda. explore static local variables to avoid repeatedly creating objects and boost performance.

Apply a unary operation to a container with std::transform over a begin and end range, using an execution policy. Sum values with std::accumulate using initial value and a binary operation.

Explore how to use std::replace, std::remove and std::sort, plus remove_if and replace_if, to modify and sort containers with lambdas and custom comparators, including pre and post C++20 erase-remove idioms.

Explore std::min, std::max, std::equal, and the any, all and none functions using lambdas to compare containers, with optional execution policies.

Learn how std::function simplifies storing and invoking callbacks in C++, compare it with traditional function pointers, and see how to store lambdas and functions in a vector for later use.

Explore implementing equal, fill, iota, copy, and accumulate algorithms with iterators to understand how the standard library and vectors operate, using practical examples and clear explanations.

Explore object orientation and inheritance in modern c++, including differences to other languages, header and source files, visibility scopes, constructors and destructors, memory management, and const-correct member functions.

Explore inheritance and abstract classes in C++ illustrating a weapon base class, a longbow derived class, and an attack interface as a pure abstract class with virtual methods.

Explore how polymorphism lets you handle agents, players, and NPCs via a single base class, using virtual functions, overrides, and base pointers in vectors.

Learn class templates in c++, including header-only declarations and a two by two matrix example using a template type T that can be float or int.

Learn how to implement operator overloads in modern C++, choosing useful operators for a matrix class, distinguishing left- and right-hand sides, and returning by value or reference.

Explore the rule of five, showing when to implement or default the destructor, copy constructor, copy assignment operator, move constructor, and move assignment operator to manage memory safely.

Explore template specialization for template functions, showing how empty angle brackets create specialized behavior for specific types like strings, where length sums the strings' lengths.

Learn to constrain templates pre C++ 20 using type traits from the type_traits header, with static_assert and disjunction to require integral or floating point types.

Explore how C++ 20 concepts replace type traits by using predefined and custom concepts with requires to constrain template functions such as edible and non numeric, improving readability.

Explore variadic templates and recursion to concatenate arbitrary arguments, then compare with C++17 fold expressions for non-recursive left- and right-fold operations.

Define a type trait to ensure a template function accepts a string view and outputs a std::string, enabling uppercase and lowercase conversions. Use static_assert, or prefer concepts in C++20.

Explore std::optional, a C++17 wrapper that signals absent values. Learn to use has_value, value, and operator*, and understand why optional can replace empty strings or exceptions for error signaling.

Explore std::variant, a type-safe alternative to unions, capable of holding int, double, or string; learn to query the active type with holds_alternative and extract values with get.

Explore std::any, a C++17 type-erasure container, to store values of any type and retrieve them with any_cast, while using type_id to check stored types and avoid errors.

Explore how c++17 attributes annotate functions and types to guide the compiler and reader, signaling no discard, deprecation, may be unused, and likely switch case hints.

Explore std::ranges in C++20 and C++23, including range adapters like transform, filter, drop, and take. Learn to compose operations with views and pipes for concise container and string processing.

Explore std::format, a modern C++20 feature enhanced in C++23 to build strings from multiple values, like name and age, without concatenation, using indices for order.

Discover how std::unique_ptr manages heap memory automatically, replacing manual new and delete with make_unique, ensuring destruction at scope end and unique ownership.

Explore how std::shared_ptr uses reference counting and make_shared to manage heap memory, with deletion occurring only when use_count drops to zero, and how partner pointers can create cycles.

Learn how to break cyclic references in modern C++ using weak_ptr alongside shared_ptr. The lecture covers use count behavior, lock usage, expired checks, and when to prefer unique_ptr.

Explore how to use exceptions in c++, including predefined std::exception types, division by zero handling, and custom ones via inheritance; catch with what() messages.

Leverage multithreading in C++ using std::thread to run a worker function in parallel, passing in values and collecting results via an output reference with std::ref, joined after completion.

Explore how threads share memory and risk race conditions when updating a global counter. Use a mutex with a lock guard and a local counter to reduce locking.

Learn to use std::async to launch functions asynchronously and obtain a future, enabling wait and get to retrieve results for io-bound tasks. For cpu-bound work, use a standard thread.