Modern Features

By the end of this lesson you'll write modern, idiomatic C++: let the compiler deduce types with auto , loop cleanly with range-based for , pass behaviour around with lambdas, model "maybe a value" with std::optional , unpack data with structured bindings, and compute at compile time with constexpr .

Part of the free C++ course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn

💡 Real-World Analogy

Think of "old" C++ as filling in a paper form where you must hand-write the same details in every box. Modern C++ is the smart online form: auto auto-fills the type for you, range-based for reads every row without you tracking line numbers, and std::optional is a field that's clearly marked "may be left blank" instead of you writing -1 and hoping the next reader knows it means "empty". The language does the bookkeeping so you can focus on the meaning.

🧭 A Quick Map of the Standards

Standard

Headline features

C++11

auto , range-based for , lambdas, nullptr , brace init

C++14

generic lambdas, relaxed constexpr

C++17

structured bindings, std::optional , if / switch with initialiser

C++20

concepts, ranges, constexpr almost everywhere

You select a standard with a compiler flag, e.g. -std=c++17 or -std=c++20 . Our runner uses a modern standard, so every example below runs as written.

1. auto , Range-Based for , nullptr & Brace Init

auto tells the compiler "work out the type from the value" — it's still fully static, just less typing. Range-based for walks every element without you managing an index; reach for const auto& by default so you read each element with no copying. nullptr is the type-safe "no pointer" (never use 0 or NULL any more), and brace initialisation with { } works for everything and blocks silent narrowing. Read the worked example, run it, then you'll write your own.

Your turn. The program below averages some temperatures — fill in the two blanks marked ___ using the hints, then run it.

2. Lambdas, Structured Bindings & std::optional

A lambda is a function you can write inline and store in a variable: [capture](args) { body } . The capture list decides which outside variables it can see — [x] copies x (by value), [&x] shares it (by reference). A structured binding , auto [a, b] = pair; , unpacks a pair, tuple, or struct into named pieces in one line. And std::optional<T> models "a T that might be missing" — check it with .has_value() and read it safely with .value_or(fallback) . The if (init; cond) form (C++17) lets you declare and test in a single, tightly-scoped line.

Now you try. Split a pair with a structured binding, then guard an optional before reading it. Fill in the two blanks:

3. constexpr , switch with Initialiser & a C++20 Peek

constexpr marks something the compiler can compute before the program runs — so it costs nothing at run time and can do things ordinary values can't, like sizing an array. The switch (init; value) form mirrors the if initialiser, keeping a helper variable scoped to just that block. Finally, a brief look at C++20 : concepts name a requirement a template type must meet (clearer errors than the old SFINAE tricks), and ranges let you pipe algorithms together with | .

Pro Tips

• 💡 Default to const auto& in range-based loops — no copies, and you can't accidentally mutate the source.
• 💡 Capture lambdas by value if the lambda may outlive the variables; [&] is for short-lived, local use only.
• 💡 Return std::optional from functions that might find nothing — it documents "may be empty" far better than a magic -1 .
• 💡 Prefer brace init { } — it works everywhere and refuses to silently truncate (narrow) your data.

Common Errors (and the fix)

• Dangling lambda capture by reference: a lambda using [&] reads a local that's already gone → undefined behaviour / crash. If the lambda outlives the variable, capture by value ( [=] or [x] ) so it owns a copy.
• auto drops const and & : auto x = ref; makes a copy , not a reference, and strips const . When you want a reference, write it explicitly: const auto& x = ref; .
• "terminate called after throwing bad_optional_access ": you called .value() on an empty optional . Check .has_value() first, or use .value_or(fallback) .
• "narrowing conversion ... inside { } ": brace init refuses to truncate, e.g. int n { 3.9 } ; won't compile. Use the right type ( double n { 3.9 } ; ) or cast deliberately with int n { static_cast<int>(3.9) } ; .

📋 Quick Reference (feature → version)

Feature

Syntax

Since

Type deduction

auto x = 42;

Range-based for

for (const auto& e : v)

Lambda

[x](int n){ return n+x; }

Null pointer

int* p = nullptr;

Brace init

vector<int> v{1,2,3};

Structured binding

auto [a, b] = pair;

Optional

optional<int> o = nullopt;

if / switch init

if (auto r = f(); r) ...

constexpr fn

constexpr int sq(int x)

C++11/14

Concepts / ranges

template<Number T>

Frequently Asked Questions

Mini-Challenge: Cheapest Item Finder

No blanks this time — just a brief and an outline to keep you on track. Combine everything: a vector of pairs, a function returning std::optional , a range-based for , and structured bindings. Build it, run it, and check your output against the example in the comments.

🎉 Lesson Complete

• ✅ auto deduces a single static type — less typing, same safety
• ✅ Range-based for with const auto& reads elements with no copies
• ✅ Lambdas capture by value [x] (copy) or by reference [&x] (shared)
• ✅ nullptr , structured bindings, and brace init { } are the modern defaults
• ✅ std::optional models "maybe a value" — check .has_value() / use .value_or()
• ✅ if / switch initialisers and constexpr tighten scope and move work to compile time
• ✅ Next lesson: Operator Overloading — give your own types natural + , == , and << behaviour

Practice quiz

Continue this course

• Previous: Constexpr & Compile-Time Programming
• Next: Operator Overloading