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

Utilizzo di std::apply su std::expected in C++23
Utilizzo di std::apply su std::expected in C++23
Lina Fontaine
Mercoledì 18 settembre 2024 20:26:40

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 std::expected type viene utilizzato negli script per facilitare la gestione degli errori in C++23. L'obiettivo principale è sviluppare una funzione generica chiamata magic_apply che può trasmettere l'output di diversi std::expected 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. magic_apply è abbastanza flessibile perché può richiedere un numero qualsiasi di std::expected parametri utilizzando modelli variadici. Prima di chiamare la funzione con il contenuto di any std::expected oggetto, la logica fondamentale di magic_apply utilizza un'espressione di piegatura, (... && args.has_value()), per accertarsi di tutto std::expected gli oggetti hanno valori validi.

Questa idea è illustrata nel primo esempio di script utilizzando tipi semplici come int E double. Definisce a compute_all funzione che esegue un calcolo di base, e getA E getB funzioni che ritornano std::expected tipi. Se entrambi i valori from getA E getB sono legittimi, possiamo chiamare compute_all utilizzando magic_apply; 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, string tipi e lambda functions vengono utilizzati.

Riduzione della complessità nella gestione degli errori C++ con `std::expected}

Script C++23 che utilizza modelli Variadic

#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;
}

Combinazione di valori C++23 di risultati diversi {std::expected}

Script C++23 che utilizza funzioni Lambda

#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 std::expected 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 std::expected 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 std::expected valori con variadic templates.

La versatilità di magic_apply ne consente l'utilizzo con funzioni che accettano una varietà di tipi di argomenti. L'implementazione è ulteriormente semplificata utilizzando decltype, 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 std::expected 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.

Domande frequenti sui modelli Variadic e std::expected

  1. Cosa è std::expected?
  2. È un tipo di modello C++ che può contenere un errore o un valore valido e viene utilizzato per la gestione degli errori.
  3. Come funziona magic_apply lavoro?
  4. Elimina la necessità di ripetuti controlli degli errori combinando i risultati di numerosi std::expected valori e passarli a una funzione.
  5. Cosa sono i modelli variadici?
  6. I modelli di variabili offrono una grande libertà nella progettazione delle funzioni consentendo alle funzioni di accettare un numero arbitrario di parametri.
  7. Perché usare decltype In magic_apply?
  8. Utilizzando i valori di std::expected oggetti per determinare automaticamente il tipo restituito della funzione chiamata.
  9. È magic_apply in grado di gestire vari tipi di errore?
  10. Sì, può essere fatto funzionare con std::expected valori con vari tipi di errore con alcune modifiche.
  11. Quali vantaggi offre l'utilizzo std::expected offerta?
  12. Quando si gestiscono gli errori, offre un approccio più espressivo e pulito rispetto a tecniche più convenzionali come eccezioni o codici restituiti.
  13. È std::unexpected parte di std::expected?
  14. Inoltre std::expected, std::unexpected rappresenta, infatti, un valore errato.
  15. È possibile utilizzare azioni asincrone magic_apply?
  16. È infatti adattabile da maneggiare std::expected valori restituiti dalle operazioni asincrone.
  17. Cos'è un'espressione di piega?
  18. In questo caso, la funzionalità in C++ chiamata espressione di piegatura viene utilizzata per verificare se all std::expected gli oggetti contengono valori validi in modo semplice.

Concludendo:

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.