C++ Academy · Lezione

Pattern di gestione degli errori

Comporre optional ed expected

Lezione 4 di 413 passaggi

Pattern di gestione degli errori è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

Due strumenti, un obiettivo

std::optional e std::expected sostituiscono entrambi i valori sentinella soggetti a errori. Questa lezione mostra come combinarli e comporli in modo ordinato.

Ritorno anticipato in caso di assenza

Un modello semplice e leggibile: verifichi l'optional e interrompa subito l'esecuzione se è vuoto, prima di proseguire.

#include <iostream>
#include <optional>
std::optional<int> parse(bool ok) { return ok ? std::optional<int>(5) : std::nullopt; }
int main() {
    auto v = parse(true);
    if (!v) { std::cout << "no value\n"; return 0; }
    std::cout << *v + 1 << "\n";
}

Da optional a expected

Converta un optional privo di valore in un errore descritto quando il chiamante ha bisogno di conoscerne il motivo.

#include <expected>
#include <optional>
#include <string>
std::expected<int, std::string> require(std::optional<int> o) {
    if (o) return *o;
    return std::unexpected("value missing");
}
int main() {}

Concatenare con value_or

Quando diverse ricerche contribuiscono a un unico risultato, value_or consente di fornire valori predefiniti direttamente nell'espressione, senza if annidati.

#include <iostream>
#include <optional>
int setting(std::optional<int> user, int fallback) {
    return user.value_or(fallback);
}
int main() {
    std::cout << setting(std::nullopt, 42) << "\n";
}

Propagare gli errori verso l'alto

Con std::expected, una funzione può esaminare il risultato di una chiamata secondaria e inoltrarne l'errore invariato, creando una pipeline di errori.

#include <expected>
#include <string>
using R = std::expected<int, std::string>;
R step1(bool ok) { return ok ? R(2) : R(std::unexpected("step1 failed")); }
R run(bool ok) {
    auto r = step1(ok);
    if (!r) return std::unexpected(r.error());
    return *r * 10;
}
int main() {}

and_then monadico

In C++23, and_then concatena operazioni che restituiscono ciascuna un optional o un expected e interrompe la catena al primo errore, senza una cascata manuale di if.

transform per il mapping

transform applica una funzione ordinaria al valore restituito con successo e lascia invariati gli errori o l'assenza di valore, mappando soltanto il percorso positivo.

or_else per il recupero

or_else esegue un fallback che può fornire un valore sostitutivo o un errore alternativo quando il valore originale è assente o l'operazione non è riuscita.

Scegliere tra i due

Usi optional quando l'assenza non richiede spiegazioni, come nel caso di un elemento non trovato nella cache. Usi expected quando il chiamante deve distinguere i motivi dell'errore, ad esempio un errore di analisi da un errore di autorizzazione.

Evitare sentinelle miste

Non combini i vecchi codici di errore con optional/expected nella stessa API. Scelga una strategia coerente, così i chiamanti gestiranno gli errori in modo uniforme.

Mantenere gli errori tipizzati

Preferisca un enum o una struct piccola per il tipo di errore, invece di semplici stringhe, quando gli errori vengono verificati a livello programmatico; le stringhe sono più adatte ai messaggi rivolti alle persone.

Verifica rapida

Verifichi la propria comprensione dei modelli di gestione degli errori.

Rispondi nella lezione interattiva

Riepilogo

Ha imparato i modelli di gestione degli errori:

Il ritorno anticipato in caso di assenza o errore mantiene il codice lineare.
Converta optional in expected quando è necessario indicare un motivo.
Componga le operazioni con and_then, transform e or_else (C++23).
Mantenga la coerenza ed eviti di combinare i valori sentinella con optional/expected.

Gratis per iniziare

Impara C++ con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 51
Lezioni: 203

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Pattern di gestione degli errori» è gratuita?

Sì — il testo completo di «Pattern di gestione degli errori» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Pattern di gestione degli errori»?

Comporre optional ed expected Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Pattern di gestione degli errori»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C++ Academy