std::expected e la gestione degli errori senza eccezioni
Le eccezioni sono uno strumento potente per gestire gli errori, ma non sono sempre la scelta ideale.
Le eccezioni sono uno strumento potente per gestire gli errori, ma non sono sempre la scelta ideale. In alcuni contesti, come i sistemi embedded, il codice ad altissime prestazioni o le situazioni in cui gli errori sono frequenti e previsti, si preferisce un approccio che renda gli errori parte esplicita del valore di ritorno. Lo standard C++23 introduce std::expected, un tipo che rappresenta il risultato di un'operazione che può concludersi con un valore atteso oppure con un errore, senza ricorrere al meccanismo delle eccezioni.
L'idea di fondo
Un oggetto std::expected è parametrizzato su due tipi: quello del valore atteso in caso di successo e quello dell'errore in caso di fallimento. In ogni momento contiene o l'uno o l'altro. Questo costringe chi chiama la funzione a considerare esplicitamente entrambi gli esiti, poiché l'errore non è nascosto in un canale separato come accade con le eccezioni, ma è parte integrante del valore restituito.
#include <expected>
#include <string>
// Restituisce un intero in caso di successo o un messaggio d'errore
std::expected<int, std::string> divide(int numerator, int denominator) {
if (denominator == 0) {
// Segnala l'errore senza lanciare eccezioni
return std::unexpected("Divisione per zero");
}
return numerator / denominator;
}
Il valore di successo si restituisce normalmente, mentre l'errore si avvolge nella funzione std::unexpected, che segnala inequivocabilmente l'esito negativo.
Consumare il risultato
Chi riceve un std::expected verifica l'esito con il metodo has_value oppure valutando direttamente l'oggetto in un contesto booleano. Il valore atteso si ottiene con value, mentre l'errore si estrae con error. Questa simmetria rende il codice di gestione esplicito e leggibile.
#include <iostream>
int main() {
auto result = divide(10, 0);
if (result) {
std::cout << "Risultato: " << result.value() << std::endl;
} else {
// Accede all'errore contenuto
std::cout << "Errore: " << result.error() << std::endl;
}
return 0;
}
Anche std::expected offre il metodo value_or, che restituisce il valore atteso oppure un valore di riserva quando l'operazione è fallita, utile quando un errore può essere assorbito con un valore predefinito.
Il confronto con std::optional
A prima vista std::expected somiglia a std::optional, ma la differenza è sostanziale. Un optional comunica soltanto la presenza o l'assenza di un valore, senza spiegarne il motivo; un expected, invece, quando fallisce trasporta un'informazione dettagliata sull'errore. Si sceglie optional quando l'assenza non ha bisogno di spiegazioni, expected quando è importante sapere perché l'operazione non è riuscita.
Concatenare operazioni
Uno degli aspetti più eleganti di std::expected è la possibilità di comporre più operazioni che possono fallire, attraverso metodi funzionali come and_then, che prosegue la catena solo in caso di successo, e transform, che trasforma il valore atteso lasciando inalterato l'eventuale errore. Se un passaggio fallisce, l'errore si propaga automaticamente lungo la catena, senza bisogno di controlli intermedi.
#include <expected>
#include <string>
std::expected<int, std::string> parse(const std::string& text);
void process(const std::string& input) {
// Il calcolo prosegue solo se il parsing riesce
auto outcome = parse(input)
.transform([](int value) { return value * 2; });
}
Vantaggi e considerazioni
La gestione degli errori tramite std::expected rende il flusso di controllo esplicito e prevedibile: non ci sono salti nascosti come con le eccezioni, e ogni possibile errore è visibile nella firma della funzione. Questo approccio è particolarmente apprezzato dove le prestazioni sono critiche o dove le eccezioni sono sconsigliate. Non sostituisce del tutto le eccezioni, che restano appropriate per errori davvero eccezionali e rari, ma offre un'alternativa disciplinata per gli errori attesi e frequenti. Con l'arrivo di std::expected, il C++ dispone finalmente di uno strumento standard ed elegante per un modello di gestione degli errori a lungo diffuso solo tramite librerie di terze parti.