Utilizzo di std::apply su std::expected in C++23

Semplificazione della gestione degli errori in C++23

Gestire in modo efficace gli errori e gestire i valori restituiti è essenziale nello sviluppo C++ di oggi. Il metodo tipico di lavorare con funzioni che restituiscono tipi {std::expected} include numerosi controlli e codice di gestione degli errori, che possono complicare la logica e rendere il codice più difficile da gestire.

Questo documento esamina l'uso di un metodo più sofisticato e generale per semplificare la gestione degli errori. Per ridurre il codice standard e migliorare la leggibilità, esamineremo la costruzione di un metodo `magic_apply` che aggrega i risultati di molti valori {std::expected} e li passa a un'altra funzione.

Comando	Descrizione
std::expected	Un tipo di modello utilizzato in C++ per la gestione degli errori che ha la capacità di archiviare sia valori che errori.
std::unexpected	Se utilizzato con std::expected, rappresenta un valore di errore imprevisto.
template<typename...>	Delinea un modello variadico con una quantità infinita di argomenti del modello che può accettare.
decltype	Utilizzato nella programmazione dei modelli, in particolare per scoprire il tipo di espressione.
args.value()	Se un oggetto std::expected ha un valore, accede al valore in esso contenuto.
args.has_value()	Verifica se un valore è presente in un oggetto std::expected.
(... && args.has_value())	Per determinare se ogni oggetto std::expected ha valori, piega l'espressione.
func(args.value()...)	Utilizza i valori dell'oggetto std::expected per chiamare la funzione del metodo.
return unexpected<Err>(args.error()...)	Restituisce un errore imprevisto contenente gli errori degli oggetti std::expected.

Gestione efficace degli errori utilizzando modelli di variabili

IL type viene utilizzato negli script per facilitare la gestione degli errori in C++23. L'obiettivo principale è sviluppare una funzione generica chiamata che può trasmettere l'output di diversi valori in un'altra funzione. In questo modo si elimina il noioso controllo degli errori che di solito è necessario quando si lavora con molti std::expected i valori sono ridotti. è abbastanza flessibile perché può richiedere un numero qualsiasi di parametri utilizzando modelli variadici. Prima di chiamare la funzione con il contenuto di any oggetto, la logica fondamentale di magic_apply utilizza un'espressione di piegatura, , per accertarsi di tutto gli oggetti hanno valori validi.

Questa idea è illustrata nel primo esempio di script utilizzando tipi semplici come E . Definisce a funzione che esegue un calcolo di base, e getA E funzioni che ritornano tipi. Se entrambi i valori from E getB sono legittimi, possiamo chiamare utilizzando ; in caso contrario, l'errore viene propagato. Riducendo il codice boilerplate, questo metodo migliora la leggibilità e la manutenibilità. Un'idea simile è presentata nella seconda sceneggiatura, ma per evidenziare la versatilità dell'approccio, tipi e lambda functions vengono utilizzati.

#include <expected>
#include <string>
#include <iostream>
#include <tuple>

using namespace std;

template<typename Func, typename... Args, typename Err>
auto magic_apply(Func func, const expected<Args, Err>&... args) -> expected<decltype(func(args.value()...)), Err> {
    if ((... && args.has_value())) {
        return func(args.value()...);
    } else {
        return unexpected<Err>(args.error()...);
    }
}

expected<int, string> getA(int x) {
    if (x > 0) return x;
    return unexpected<string>("Error in getA");
}

expected<double, string> getB(double y) {
    if (y > 0) return y;
    return unexpected<string>("Error in getB");
}

double compute_all(int a, double b) {
    return a + b;
}

int main() {
    auto result = magic_apply(compute_all, getA(10), getB(20.5));
    if (result) {
        cout << "Result: " << result.value() << endl;
    } else {
        cout << "Error: " << result.error() << endl;
    }
    return 0;
}

#include <expected>
#include <string>
#include <iostream>

using namespace std;

template<typename Func, typename... Args, typename Err>
auto magic_apply(Func func, const expected<Args, Err>&... args) -> expected<decltype(func(args.value()...)), Err> {
    bool all_valid = (args.has_value() && ...);
    if (all_valid) {
        return func(args.value()...);
    } else {
        return unexpected<Err>(args.error()...);
    }
}

expected<string, string> getA(bool flag) {
    if (flag) return "SuccessA";
    return unexpected<string>("Failed A");
}

expected<string, string> getB(bool flag) {
    if (flag) return "SuccessB";
    return unexpected<string>("Failed B");
}

string compute_all(const string& a, const string& b) {
    return a + " and " + b;
}

int main() {
    auto result = magic_apply(compute_all, getA(true), getB(true));
    if (result) {
        cout << "Result: " << result.value() << endl;
    } else {
        cout << "Error: " << result.error() << endl;
    }
    return 0;
}

Miglioramento della gestione degli errori C++ con modelli Variadic

La capacità di migliorare notevolmente la gestione degli errori nei sistemi complessi è un altro vantaggio cruciale dell'utilizzo in C++. Combinare perfettamente i risultati di molte azioni asincrone è essenziale nelle situazioni in cui cedono tipi. Oltre a semplificare il codice, questo metodo garantisce una forte gestione degli errori. È possibile creare funzioni più versatili e generiche combinando un numero arbitrario di valori con variadic templates.

La versatilità di ne consente l'utilizzo con funzioni che accettano una varietà di tipi di argomenti. L'implementazione è ulteriormente semplificata utilizzando , che deduce automaticamente il tipo restituito della chiamata di funzione combinata. Inoltre, questa tecnica può essere ampliata per gestire attività più complesse, inclusa la fusione valori con altri tipi di errore o alterando i valori prima di inviarli alla funzione. Grazie alla sua adattabilità, il modello può essere utilizzato per un'ampia gamma di compiti, da calcoli semplici a operazioni complesse.

In C++23, l'implementazione di una funzione generica per gestire più valori std::expected migliora notevolmente la leggibilità del codice e semplifica notevolmente la gestione degli errori. La funzione magic_apply riduce il codice boilerplate e migliora la manutenibilità utilizzando modelli variadici per assicurarsi che tutti i valori previsti siano corretti prima dell'elaborazione. Questo metodo offre una soluzione flessibile che può essere applicata a diverse situazioni e fornisce alla moderna programmazione C++ un modo più pulito ed efficace per gestire gli errori.