C++17: Lo Standard Pratico

Esplora le funzionalità più incisive di C++17: structured bindings, std::optional/variant/any, std::string_view, std::filesystem, if constexpr e i nuovi attributi.

Perché C++17 è Importante

Il C++17 viene spesso chiamato lo "standard pratico" perché ha introdotto una gran quantità di funzionalità che semplificano la scrittura quotidiana del codice senza richiedere una conoscenza approfondita della metaprogrammazione con i template. Ha rimosso zavorre del passato (come std::auto_ptr e i trigrafi), ha aggiunto i cosiddetti vocabulary type (std::optional, std::variant, std::any) e ha introdotto zucchero sintattico che rende il codice più corto e più chiaro. Se oggi scrivi C++ per la produzione, il C++17 dovrebbe essere la tua base minima.

Structured Binding e Istruzioni di Inizializzazione

Gli structured binding ti permettono di spacchettare gli aggregati (struct, array, pair, tuple) in variabili con nome in un'unica dichiarazione. Combinati con gli inizializzatori di if/switch, eliminano molte variabili temporanee:

structured_bindings.cpp

#include <iostream>
#include <map>
#include <string>
#include <tuple>

std::tuple<std::string, int, double> get_employee() {
    return {"Alice", 42, 95000.0};
}

int main() {
    // Structured binding with tuple
    auto [name, age, salary] = get_employee();
    std::cout << name << " is " << age << " years old\n";

    // Structured binding with map iteration
    std::map<std::string, int> scores{{"Alice", 95}, {"Bob", 87}};
    for (const auto& [student, score] : scores) {
        std::cout << student << ": " << score << "\n";
    }

    // if with initializer — the variable is scoped to the if/else
    if (auto it = scores.find("Alice"); it != scores.end()) {
        std::cout << "Found: " << it->second << "\n";
    } else {
        std::cout << "Not found\n";
    }
    // 'it' no longer exists here — no scope leakage

    // Structured binding with array
    int arr[3] = {10, 20, 30};
    auto [x, y, z] = arr;
    std::cout << x << ", " << y << ", " << z << "\n";

    return 0;
}

Vocabulary Type: optional, variant, any

std::optional rappresenta un valore che può essere presente oppure no (e sostituisce i valori sentinella e i parametri di output). std::variant è una union type-safe. std::any contiene qualsiasi tipo copiabile con controllo del tipo a runtime:

vocabulary_types.cpp

#include <iostream>
#include <optional>
#include <variant>
#include <any>
#include <string>

// optional: replaces "return -1 on failure" patterns
std::optional<int> find_index(const std::string& haystack, char needle) {
    for (size_t i = 0; i < haystack.size(); ++i) {
        if (haystack[i] == needle) return static_cast<int>(i);
    }
    return std::nullopt;  // no value
}

int main() {
    // std::optional
    auto idx = find_index("hello", 'l');
    if (idx.has_value()) {
        std::cout << "Found at index " << *idx << "\n";       // 2
    }
    std::cout << idx.value_or(-1) << "\n";  // safe default

    // std::variant — type-safe union
    std::variant<int, double, std::string> value = "hello";
    std::cout << std::get<std::string>(value) << "\n";

    // Visit pattern — exhaustive handling of all types
    std::visit([](const auto& v) {
        std::cout << "Value: " << v << "\n";
    }, value);

    value = 3.14;  // now holds a double
    std::cout << std::get<double>(value) << "\n";

    // std::any — truly any type, with runtime checking
    std::any data = 42;
    std::cout << std::any_cast<int>(data) << "\n";
    data = std::string("world");
    std::cout << std::any_cast<std::string>(data) << "\n";

    return 0;
}

string_view e filesystem

std::string_view è un riferimento leggero e non proprietario a una stringa. Evita le copie quando devi solo leggere una stringa. std::filesystem offre manipolazione dei percorsi e operazioni sui file portabili e multipiattaforma:

string_view_fs.cpp

#include <iostream>
#include <string>
#include <string_view>
#include <filesystem>

namespace fs = std::filesystem;

// string_view avoids copying — just a pointer + length
void print_trimmed(std::string_view sv) {
    auto start = sv.find_first_not_of(' ');
    auto end = sv.find_last_not_of(' ');
    if (start != std::string_view::npos) {
        std::cout << sv.substr(start, end - start + 1) << "\n";
    }
}

int main() {
    std::string name = "  Hello, C++17!  ";
    print_trimmed(name);       // no copy — string_view binds to string
    print_trimmed("  world  "); // no copy — binds to string literal

    // std::filesystem — portable path operations
    fs::path source_dir = "/home/user/project/src";
    std::cout << "Filename: " << source_dir.filename() << "\n";
    std::cout << "Parent:   " << source_dir.parent_path() << "\n";
    std::cout << "Exists:   " << fs::exists(source_dir) << "\n";

    // Iterate directory entries
    for (const auto& entry : fs::directory_iterator(".")) {
        if (entry.is_regular_file()) {
            std::cout << entry.path().filename()
                      << " (" << entry.file_size() << " bytes)\n";
        }
    }

    // Create directories recursively
    fs::create_directories("output/logs/2024");

    return 0;
}

if constexpr, CTAD e Altro

if constexpr abilita la ramificazione a tempo di compilazione all'interno dei template — i rami che non corrispondono vengono scartati completamente. La Class Template Argument Deduction (CTAD) ti permette di omettere gli argomenti del template quando il compilatore può dedurli. Le fold expression semplificano i parameter pack dei template variadici:

if_constexpr.cpp

#include <iostream>
#include <string>
#include <vector>
#include <type_traits>

// if constexpr — branches resolved at compile time
template<typename T>
std::string to_string_safe(T value) {
    if constexpr (std::is_arithmetic_v<T>) {
        return std::to_string(value);
    } else if constexpr (std::is_same_v<T, std::string>) {
        return value;
    } else {
        return "[unsupported type]";
    }
}

// Fold expressions — collapse parameter packs
template<typename... Args>
auto sum(Args... args) {
    return (args + ...);  // unary right fold
}

template<typename... Args>
void print_all(Args&&... args) {
    ((std::cout << args << " "), ...);  // fold over comma
    std::cout << "\n";
}

int main() {
    std::cout << to_string_safe(42) << "\n";
    std::cout << to_string_safe(std::string("hi")) << "\n";

    std::cout << sum(1, 2, 3, 4, 5) << "\n";  // 15
    print_all(1, "hello", 3.14);               // 1 hello 3.14

    // CTAD — no need for std::vector<int>
    std::vector v{1, 2, 3, 4, 5};   // deduced as vector<int>
    std::pair p{"hello", 42};        // deduced as pair<const char*, int>

    // Nested namespaces
    // namespace A::B::C { } instead of namespace A { namespace B { namespace C { } } }

    // Inline variables — can be defined in headers without ODR violations
    // inline constexpr int version = 17;

    return 0;
}

Buona pratica

Il C++17 ha standardizzato tre attributi importanti:

[[nodiscard]] — Emette un warning se il valore di ritorno viene ignorato. Usalo sulle funzioni il cui valore di ritorno andrebbe sempre controllato (codici di errore, risorse allocate, funzioni factory).

[[maybe_unused]] — Sopprime i warning su variabili e parametri non utilizzati. Utile per le variabili usate solo nelle build di debug o in codice specifico per una piattaforma.

[[fallthrough]] — Indica un fallthrough intenzionale in un case di uno switch, silenziando i warning del compilatore.

Adotta [[nodiscard]] in modo aggressivo nelle tue API. Un codice di errore ignorato è un bug pronto a esplodere.

Insidia

Non restituire mai una std::string_view che fa riferimento a una stringa locale. Poiché string_view non possiede i propri dati, la stringa sottostante può essere distrutta prima che la vista venga usata, causando comportamento indefinito:

// PERICOLOSO — restituisce una vista su un temporaneo distrutto!
std::string_view bad() {
    std::string s = "hello";
    return s;  // s viene distrutta alla fine della funzione!
}

Regola pratica: usa string_view per i parametri (lettura dei dati) e restituisci std::string per i valori di ritorno (possesso dei dati).

Concetti chiave

Gli structured binding (auto [a, b] = ...) spacchettano in modo pulito tuple, pair, struct e array
std::optional sostituisce i valori sentinella; std::variant sostituisce le union non sicure; std::any serve per i tipi davvero dinamici
std::string_view evita le copie per l'accesso in sola lettura alle stringhe — ma attenzione ai riferimenti pendenti
if constexpr abilita la ramificazione a tempo di compilazione nei template, eliminando il boilerplate SFINAE
La CTAD lascia dedurre al compilatore gli argomenti del template: std::vector v{1,2,3} funziona e basta
Usa [[nodiscard]] sulle funzioni il cui valore di ritorno non deve essere ignorato

Quiz — Metti alla prova le tue conoscenze

(15 XP)

1. Che cosa fa `auto [x, y] = std::make_pair(1, 2.0);` in C++17?

2. Che cosa rappresenta `std::optional<int>`?

3. Perché restituire una `std::string_view` da una funzione è pericoloso se fa riferimento a una stringa locale?

Algoritmi paralleli e policy di esecuzione

C++20: I Big Four e Altro