Master the Latest C++ Features: From Auto to Coroutines (C++11‑C++20)

C++11

Auto type deduction ( auto ) lets the compiler infer the variable type. auto x = 42; // deduced as int Range‑based for loop simplifies iteration over containers.

for (auto &elem : container) {
    // process elem
}

Smart pointers ( std::unique_ptr , std::shared_ptr ) provide automatic memory management.

std::unique_ptr<int> p = std::make_unique<int>(10);

Lambda expressions define anonymous functions inline. auto lambda = [](int x) { return x * 2; }; Concurrency ( std::thread , std::mutex ) adds basic thread support.

std::thread t([](){ /* work */ });
 t.join();

Rvalue references and move semantics ( && , std::move ) improve resource management and performance.

void func(std::vector<int>&& vec) {
    // handle moved resources
}

C++14

Return type deduction ( auto ) allows functions to deduce their return type. auto func() { return 42; } Lambda capture by move enables lambdas to capture objects by value and move them.

auto lambda = [x = std::move(my_object)]() { /* use x */ };

std::make_unique simplifies creation of unique_ptr .

auto p = std::make_unique<int>(10);

C++17

Structured bindings decompose tuples, pairs, etc. auto [x, y] = std::make_pair(1, 2); std::optional represents a value that may be absent. std::optional<int> opt = 42; std::filesystem adds standard library support for file system operations.

namespace fs = std::filesystem;
for (const auto &entry : fs::directory_iterator("/path/to/dir")) {
    std::cout << entry.path() << std::endl;
}

std::string_view provides a lightweight, non‑owning view of a string.

std::string_view str_view = "Hello, world!";

C++20

Concepts introduce type constraints to make templates more readable and debuggable.

template<typename T> concept Incrementable = requires(T x) { ++x; };

template<Incrementable T> void increment(T& x) { ++x; }

Ranges library simplifies container operations with pipeline syntax.

#include <ranges>
auto result = data | std::views::transform([](int x) { return x * 2; });

Coroutines simplify asynchronous programming and generators.

#include <coroutine>
std::future<int> get_data() {
    co_return 42;
}

Spaceship operator ( <=> ) provides default three‑way comparison.

struct MyType {
    int x, y;
    auto operator<=>(const MyType&) const = default;
};

std::span offers a lightweight view over arrays or containers. std::span<int> span(arr, size); consteval and constinit enable compile‑time evaluation and constant initialization.

consteval int square(int x) { return x * x; }