Modern C++: From First Program to Concurrency and Templates

You'll build a program that creates a std::string, grows it with + and append, reads a full line with std::getline, and prints a personalized greeting. You'll see why modern C++ defaults to std::string over C-style char arrays, and exactly how std::cin and std::getline behave differently around whitespace.

You'll get a landscape view of where C++ actually lives today — the engines behind major games, the C++ running inside your web browser right now, the industries it quietly rules, and the systems software most developers never see. More importantly, you'll learn why C++ has resisted replacement in several of these domains, separating real technical moats from plain inertia.

You'll write a program that classifies a value across several bands — here, the temperature of a dragon's lair — using an if / else-if chain, then compress smaller logic into a single ternary expression and learn when each form fits. You'll also see why bracing single-statement bodies kills a whole class of bugs, and how the dangling-else trap sneaks in.

You'll map numbers to outcomes with a switch — turning a day number into the day's task — using case labels, default, and break, then write a deliberate fallthrough that lets several cases stack their effects. You'll learn why switch only works on integral and enum types (not strings) and why a forgotten break is the canonical switch bug.

You'll repeatedly halve a number with a while loop, then rewrite the exact same logic as a do-while to feel precisely when each checks its condition. You'll come away knowing when to reach for each: do-while when the body must run at least once, while when it might not run at all.

You'll sum the numbers one to ten with a classic three-part for loop, then rewrite it as a C++11 range-based for over a list of values. You'll learn the rule of thumb that decides between them: range-based when you just want every element, classic when you need the index or non-trivial stepping.

You'll iterate over a range of numbers, using continue to skip the entries you want to ignore and break to bail out the instant a running sum crosses a threshold, watching the control flow play out in the output. You'll also see why early exits are far safer in C++ than in C, thanks to RAII cleaning up automatically.

You'll unpack the philosophy that has steered C++ for forty years: you don't pay for what you don't use, and what you do use runs as fast as hand-written code. You'll see how this shapes templates, RAII, and the lack of a mandatory garbage collector — and you'll get the honest costs too, from undefined behavior to header fragility and ABI lock-in, so you know exactly what trade-offs you're accepting.

You'll write a free function that adds two integers and call it from main with different arguments to see the results. You'll learn how return types and parameter lists work, the difference between a declaration and a definition, and why a function prototype is needed when you call a function before defining it.

You'll compare three versions of a function that takes a std::string — by value, by non-const reference, and by const reference — and watch what each does to performance and to the caller's variable. You'll learn why const reference is the default for anything bigger than a register-sized type, and why non-const references should stay rare and deliberate.

You'll build a greet function with a default greeting argument, then add overloads for different parameter types and watch the compiler pick the right one. You'll develop an intuition for overload resolution without memorizing rules, and learn to spot the ambiguities that crop up when defaults and overloads collide.

You'll define lambdas inline and use one to drive std::sort with a custom ordering on a vector. You'll work through capture lists — by value, by reference, and by named capture — and see how a lambda stores its captures in an anonymous closure type the compiler generates just for it.

You'll explore block scope by shadowing a variable name inside and outside a block, then watch a function return a pointer to a local stack variable and see the undefined behavior that follows when you dereference it. This sets up object lifetime, the stack-versus-heap distinction, and why C++ forces you to think about ownership.

You'll compare C++ against other systems languages on a demanding workload like ray tracing, and weigh that raw speed against the bugs C++ is famous for: buffer overflows, dangling pointers, data races, iterator invalidation, and template errors hundreds of lines long. You'll leave seeing both why teams choose C++ and why some are deliberately migrating away.

You'll work with a fixed-size C-style array, then rewrite the example using std::array to gain size, iterators, and bounds-aware operations at zero extra cost. You'll see firsthand how raw arrays decay to pointers when passed to functions — one of the most error-prone behaviors C++ inherited from C.

You'll create a std::vector, push_back elements, and watch its size and capacity to see how it grows geometrically, then iterate it with a range-based for. You'll learn why vector — heap-allocated and dynamically sized — is the right default whenever you don't know the element count at compile time, and how reserving capacity changes its growth behavior.

You'll build a std::map from string keys to values — here, hero names to their levels — insert with bracket syntax and emplace, look up by key, and iterate in sorted order, then swap in unordered_map for average constant-time access at the cost of unordered iteration. You'll put it to use counting how often each word appears in a sentence with a hash map.

You'll return a std::tuple of several values from a function and unpack it in one line with C++17 structured bindings, then compare it against the older std::get and std::tie approach to feel the readability win. You'll also meet std::pair, the two-value workhorse that powers std::map, and destructure key-value pairs as you iterate.

You'll run a vector through std::sort, std::find, and std::count_if from the algorithm header, supplying lambdas as predicates where needed. You'll see how iterators let the same algorithm work over any container, and get a first look at the C++20 ranges library and its pipeline-style composition with the pipe operator.

You'll see how C++ source actually becomes an executable, surveying GCC, Clang, and MSVC and how they differ in standards conformance, diagnostics, and platform reach. You'll also meet the build ecosystem you'll eventually wrestle with — Make, CMake, Ninja, Conan, vcpkg, and C++20 modules — and learn why "just compile it" is rarely just compiling it.

You'll launch std::thread workers, each running a lambda that prints output, and join them from main before exiting. You'll watch thread scheduling play out nondeterministically and learn the hard rule that every joinable thread must be joined or detached before it's destroyed — or the program terminates.

You'll create a data race by having two threads bump a shared counter with no synchronization, then fix it with a std::mutex held by a std::lock_guard that releases automatically when the scope exits. Seeing the corrupted versus correct final counts side by side makes the danger concrete, and you'll learn why std::scoped_lock is the preferred modern default.

You'll use std::async to compute a slow result in the background and retrieve it through a std::future while main keeps working, with timing output that makes the parallelism real. You'll learn the launch policies that decide whether the task runs on a new thread or lazily on the calling thread, then combine the results of several async tasks.

You'll replace the mutex-protected counter with a std::atomic<int> and watch the same two-thread program produce the correct result with no explicit lock. You'll get a beginner-friendly introduction to memory orderings and learn the crucial nuance: atomics are the right tool for specific contention, but the wrong tool for protecting compound invariants.

You'll allocate an object with std::make_unique, transfer ownership with std::move, and confirm the original handle goes null. Then you'll share an object across two std::shared_ptr handles and use std::weak_ptr to observe without owning — even deliberately creating a reference cycle, watching it leak, and breaking it with weak_ptr.

You'll throw a std::runtime_error from a function, catch it in main, and print the message — then add an RAII-wrapped resource and watch its destructor run as the stack unwinds, releasing the resource with no explicit cleanup code. You'll also meet the strong exception guarantee and the copy-and-swap technique that upholds it.

You'll open up the runtime memory layout of a C++ process — text, data, BSS, heap, and stack — and see how automatic stack storage differs from heap allocation in cost, lifetime, and failure modes. You'll learn the standard's rules for when constructors and destructors run, and why C++ developers obsess over object lifetime in ways garbage-collected programmers never have to.

You'll write a function template that returns the stronger of two values for any type T and call it with int, double, and std::string, watching one source instantiate into three distinct functions at compile time. You'll learn how the compiler deduces T from the arguments and what happens when that deduction turns ambiguous.

You'll build a Box class template that holds a value of type T and instantiate it across several different types, from a Box<int> to a Box<std::string>. This gives you the mental model that every STL container is just a class template following the same pattern — and explains, finally, why those template error messages look the way they do.

You'll take your generic comparison template and constrain its type with a C++20 concept or requires clause, then watch a bad instantiation produce a dramatically clearer compiler error — while confirming the constraint costs nothing at runtime. You'll then write your own Printable concept that requires a type be streamable to std::cout and use it to constrain a generic print function.

You'll rebuild a chain of transformations — filtering, transforming, and reducing a sequence of numbers — using the C++20 ranges library and the pipe operator, so the data flows top to bottom. Printing the intermediate stages reveals the lazy evaluation, and you'll compare it against the equivalent hand-written loop and chained algorithm calls.

You'll use std::optional as the return type of a function that might not find a value, checking has_value before printing the result or a fallback. Then you'll hold one of several types in a std::variant and use std::visit with a lambda to handle the active alternative — a tagged union, done the C++ way.

You'll write a constexpr factorial function and use it both at compile time to feed a static_assert and at runtime on user input, proving one function serves both worlds. You'll see how modern C++ lets you push more work to compile time without sacrificing readability, then apply the idea to build a lookup table computed entirely at compile time.

You'll learn why Resource Acquisition Is Initialization is the cornerstone idiom of C++: every resource — memory, files, locks, sockets — is tied to a stack object whose destructor releases it deterministically. You'll see how this powers exception safety, why C++ has no finally block, and why a leak in well-written C++ is usually a design error rather than forgotten cleanup.

You'll see how templates turn the compiler into a code generator, stamping out specialized functions and classes at compile time, and how C++20 concepts finally tame template parameters with readable errors. You'll trace the arc from C++98's accidentally Turing-complete metaprogramming to today's deliberate, ergonomic compile-time language built from constexpr and consteval — all at the level of ideas and trade-offs, not syntax.

You'll learn the story behind C++11's rvalue references and move semantics — the realization that idiomatic code was drowning in needless copies and needed a way to say "this value is about to die." You'll build a deep intuition for copy versus move at the level of pointers and ownership, the rule of zero/three/five, and why std::unique_ptr and vector resize behave as they do.

You'll revisit the classic Gang of Four patterns — singleton, factory, observer, strategy, visitor — and see how modern C++ reshapes each: std::function and lambdas collapse strategy, std::variant and std::visit transform visitor, and templates dissolve some patterns into the type system entirely. You'll leave with a pattern vocabulary calibrated to how senior C++ engineers actually write code today.

You'll tour the worlds where C++ is indispensable — embedded firmware on microcontrollers with kilobytes of RAM, hard real-time systems where every cycle is budgeted, and HPC clusters where it works beside CUDA and MPI. You'll see which subsets of the language these domains use and ban, why exceptions and dynamic allocation are often forbidden, and the career territory this range opens up.

Every programming journey starts with a single line of output. In this lecture, you'll write your very first C++ program using cout and the iostream library to print text to the console. You'll learn how the main function serves as the entry point of every C++ program, what the return statement does, and how the insertion operator sends data to the screen. Think of cout as your program's megaphone — it's how your code talks to the outside world.

Programs need memory, and variables are how C++ remembers things. In this lecture, you'll explore the core data types in C++ — int for whole numbers, double for decimals, char for single characters, and bool for true-or-false values. You'll learn how to declare variables, assign values, and understand why C++ insists on knowing the type of every piece of data before it stores it. It's like labeling boxes before you move — everything has a place and a purpose.

Numbers are great, but most real programs deal with words too. This lecture covers how to work with text in C++ using the string type from the standard library. You'll learn how to declare strings, concatenate them with the plus operator, and find their length. You'll also see how C++ strings differ from single characters stored in a char. Whether you're building a greeting generator or just storing a user's name, mastering C++ strings is essential.

A program that only talks but never listens isn't very useful. In this lecture, you'll learn how to use cin in C++ to capture input from the user via the keyboard. You'll see how the extraction operator pulls data from the input stream and stores it in a variable, and you'll discover the quirks of reading strings with spaces using getline. By the end, you'll be writing interactive C++ programs that respond to whatever the user types in.

Time to put C++ to work as your personal calculator. This lecture walks you through the arithmetic operators in C++ — addition, subtraction, multiplication, division, and the often-overlooked modulus operator. You'll learn the difference between integer division and floating-point division in C++, why dividing two ints can give you a surprising result, and how to use parentheses to control the order of operations. Math in code follows the same rules you learned in school, just with a few digital twists.

Sometimes a number isn't quite the right kind of number. In this lecture, you'll learn how C++ handles type conversions — both the automatic ones the compiler does for you (implicit casting) and the ones you trigger yourself (explicit casting). You'll see what happens when you stuff a double into an int, why narrowing conversions can silently eat your data, and how to use static_cast to convert between types safely and intentionally in C++. It's the difference between rounding gracefully and losing decimals without warning.

Welcome to the crossroads. In this lecture, you'll learn how to use if statements in C++ to execute code only when a condition is true. You'll explore comparison operators like equal-to, not-equal-to, greater-than, and less-than, and see how they produce boolean values that drive your program's decisions. Think of an if statement as a bouncer at a club — it checks the condition and only lets the code through if everything checks out.

What happens when the condition is false? In this lecture, you'll extend your C++ decision-making toolkit with else and else-if blocks. You'll learn how to create branching paths so your program can handle multiple scenarios — not just yes or no, but maybe, sort of, and everything in between. You'll write C++ code that responds differently based on a range of conditions, like grading a test score or categorizing a temperature reading.

Real decisions rarely depend on just one thing. In this lecture, you'll learn how to combine multiple conditions in C++ using logical operators — AND, OR, and NOT. You'll see how to check whether two conditions are both true, whether at least one is true, or how to flip a condition on its head. These operators let you write C++ expressions that mirror the way humans actually reason, like checking if a user is both logged in and has admin privileges.

When you have a long chain of else-if blocks all checking the same variable, there's a cleaner way. In this lecture, you'll learn how to use the switch statement in C++ to handle multiple discrete cases efficiently. You'll see how case labels work, why the break keyword is essential, and what happens when you forget it — the infamous fall-through behavior. The C++ switch statement is like a vending machine: you punch in your selection, and it delivers exactly the right result.

Sometimes you just need a quick yes-or-no decision without the ceremony of a full if-else block. In this lecture, you'll learn how to use the ternary operator in C++ — the compact, one-line conditional expression that assigns a value based on a condition. You'll see the syntax of the question-mark-colon pattern, when it makes your C++ code cleaner, and when it makes things harder to read. It's the espresso shot of conditional logic — small, strong, and best used in moderation.

When you know exactly how many times you need to repeat something, the for loop is your best friend. In this lecture, you'll learn how to construct a for loop in C++ with its three components — initialization, condition, and increment. You'll see how to count up, count down, and step by custom intervals. From printing number sequences to iterating a fixed number of times, the C++ for loop is the workhorse of controlled repetition.

Sometimes you don't know in advance how many times you need to loop — you just keep going until a condition changes. In this lecture, you'll learn how to use the while loop in C++ to repeat a block of code as long as a boolean expression remains true. You'll see how to avoid infinite loops by making sure the condition eventually becomes false, and you'll write C++ programs that loop based on user input or changing data rather than a fixed count.

What if you need the loop body to run at least once before checking the condition? That's where the do-while loop comes in. In this lecture, you'll learn how C++ handles this variation of the while loop, where the condition is checked at the bottom instead of the top. You'll see practical scenarios where do-while shines in C++, like menu-driven programs that need to display options before asking the user whether to continue.

Loops are powerful, but sometimes you need to bail out early or skip an iteration. In this lecture, you'll learn how to use break and continue statements inside C++ loops. Break immediately exits the loop entirely, while continue skips the rest of the current iteration and jumps to the next one. You'll write C++ code that searches for a value and stops as soon as it's found, and code that processes a sequence but skips over unwanted items.

  Some problems require a loop inside a loop — and that's where nested loops come in. In this lecture, you'll learn how to place one loop inside another in C++ and understand how the inner loop completes all its iterations for each single iteration of the outer loop. You'll use nested for loops in C++ to generate patterns, work with grid-like structures, and build multiplication tables. It's like a clock — the minute hand completes a full rotation for every tick of the hour hand.

Functions are the building blocks of organized code. In this lecture, you'll learn how to define a function in C++ by specifying its return type, name, and body, then call it from main. You'll see how void functions perform an action without returning anything, and how the flow of execution jumps to the function and back. Writing your own C++ functions is like creating custom tools — once built, you can use them whenever you need them without rebuilding from scratch.

  Functions become truly powerful when you can feed them different data each time. In this lecture, you'll learn how to add parameters to your C++ functions so they can accept input values when called. You'll see the difference between parameters in the function definition and arguments in the function call, and you'll practice writing C++ functions that take multiple parameters of different types. It's like giving your function a set of knobs to turn — same machine, different settings, different results.

Sometimes you don't just want a function to do something — you want it to give something back. In this lecture, you'll learn how to use return values in C++ functions to send a result back to the caller. You'll write functions that compute and return integers, doubles, booleans, and strings, and you'll see how to capture the returned value in a variable. Understanding return values in C++ is what transforms your functions from one-way messengers into full conversations between parts of your code.

What if you want the same function name to handle different types of input? That's function overloading in C++. In this lecture, you'll learn how C++ lets you define multiple functions with the same name as long as their parameter lists differ — different types, different counts, or both. You'll see how the compiler decides which version to call based on the arguments you pass. It's one of C++'s signature features, like a Swiss Army knife where the tool that pops out depends on how you grip it.

Sometimes a function has parameters that usually take the same value. In this lecture, you'll learn how to assign default values to parameters in C++ functions, so callers can omit those arguments when the default is good enough. You'll see the rules about where defaults must appear in the parameter list and how they interact with function overloading in C++. Default parameters keep your function calls clean and concise without sacrificing flexibility when you need to override the default.

  By default, C++ functions receive copies of their arguments — which means changes inside the function don't affect the originals. In this lecture, you'll learn how to use pass by reference in C++ with the ampersand symbol to let a function modify the caller's variables directly. You'll compare pass by value and pass by reference side by side and see when each approach is appropriate. Passing by reference in C++ is like handing someone your actual notebook instead of a photocopy — whatever they write stays.