📦 Tuples & Vocabulary Types

A std::tuple is a fixed-size bundle of values of different types — a struct without field names. Write make_person, which packs (name, age, height) into a std::tuple<std::string, int, double>, and get_age, which reads the age back out by position.

return std::make_tuple(std::move(name), age, height); deduces the element types from the arguments (a braced return {std::move(name), age, height}; also works because the return type is spelled out). Reading uses a compile-time index: std::get<1>(person) — positions are 0-based and there is no run-time bounds check because the index is a template argument. When a type appears only once in the tuple, std::get<int>(person) selects it by type instead.

A C++17 structured binding unpacks a pair, tuple, array or plain struct into named variables in one line: auto [a, b] = pair;. Its most common home is a range-for over a map. Write top_scorer: given a map from name to score, return the name whose score is the highest, iterating with for (const auto& [name, score] : scores) rather than .first / .second.

Track the best seen so far and let a strict > decide:

std::string best_name;                              // "" until something beats best_score
int best_score = std::numeric_limits<int>::min();   // lower than any real score
for (const auto& [name, score] : scores) {          // each pair unpacked by position: key, value
    if (score > best_score) {                       // strict '>' keeps the earliest of equal scores
        best_name = name;
        best_score = score;
    }
}
return best_name;

const auto& binds each std::pair<const std::string, int> by reference, so no name is copied; name and score are just aliases for .first and .second.

std::tie(a, b, c) builds a tuple of references to existing variables, and tuples compare lexicographically — first element decides, then the second, and so on. Write before(a, b) for the Person struct (declared above the editable region: last, first, age): true when a sorts before b by last name, then first name, then age.

return std::tie(a.last, a.first, a.age) < std::tie(b.last, b.first, b.age); — one line, no copies (references only), no nested if/else. The other classic use of std::tie is receiving a tuple into variables that already exist: std::tie(q, r) = divmod(17, 5);. In C++20 the same comparison is one operator<=> = default; on a C++17 compiler std::tie is the idiom.

std::optional<T> holds either a T or nothing (std::nullopt) — the honest return type for "might not exist", replacing sentinels like -1. Write find_index: the position of the first element equal to target, or an empty optional.

Return the index as soon as you see a match; after the loop, return "nothing":

for (std::size_t i = 0; i < v.size(); ++i) {
    if (v[i] == target) return i;   // a size_t converts to optional<size_t> implicitly
}
return std::nullopt;                // the empty state — the whole point of optional

On the caller's side, an std::optional<std::size_t> r offers:

• if (r) or r.has_value() — is there a value?
• *r — read it, unchecked (undefined behaviour if empty)
• r.value() — read it, checked: throws std::bad_optional_access if empty
• r.value_or(999) — the value, or the fallback, in one expression

std::variant<Circle, Rect> holds exactly one of its alternatives at a time — a type-safe union. std::visit(visitor, v) calls visitor(circle) or visitor(rect) depending on which is active, and refuses to compile if the visitor cannot handle every alternative. Complete AreaVisitor and area for the Circle / Rect shapes declared above the editable region.

The visitor is a struct with one operator() per alternative; std::visit picks the one matching the active type:

struct AreaVisitor {
    double operator()(const Circle& c) const { return kPi * c.radius * c.radius; }
    double operator()(const Rect& r) const   { return r.width * r.height; }
};

double area(const Shape& shape) {
    return std::visit(AreaVisitor{}, shape);   // calls the operator() for whatever shape holds
}

Other tools you will meet on a variant v:

• std::holds_alternative<Rect>(v) — is Rect the active type?
• std::get<Rect>(v) — extract it; throws std::bad_variant_access if another type is active
• std::get_if<Rect>(&v) — a pointer to it, or nullptr
• v.index() — position of the active alternative (Circle is 0, Rect is 1)

std::string_view is a non-owning (pointer, length) window onto characters that live somewhere else — a std::string, a literal, a buffer. Shrinking a view moves the window; it never copies or allocates. Write trim, which returns s without leading and trailing spaces, as a view into the same characters.

while (!s.empty() && s.front() == ' ') s.remove_prefix(1); then the same with back() and remove_suffix(1); return s;. The !s.empty() guard matters: front() on an empty view is undefined. Because the result still points into the caller's data, it is only valid while that data lives — never return a string_view into a local std::string.