Verwendung von std::apply für std::expected in C++23

Reduzieren der Komplexität bei der C++-Fehlerbehandlung mit „std::expected}“

C++23-Skript mit Variadic-Vorlagen

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

Kombinieren verschiedener {std::expected}-Ergebnisse C++23-Werte

C++23-Skript mit Lambda-Funktionen

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

Häufig gestellte Fragen zu Variadic-Vorlagen und std::expected

1. Was ist std::expected?
2. Es handelt sich um einen C++-Vorlagentyp, der einen Fehler oder einen gültigen Wert enthalten kann und zur Fehlerverwaltung verwendet wird.
3. Wie funktioniert magic_apply arbeiten?
4. Durch die Kombination der Ergebnisse mehrerer Fehler entfällt die Notwendigkeit wiederholter Fehlerprüfungen std::expected Werte und deren Übergabe an eine Funktion.
5. Was sind Variadic-Vorlagen?
6. Variable Vorlagen bieten viel Freiheit beim Funktionsdesign, indem sie es Funktionen ermöglichen, eine beliebige Anzahl von Parametern zu akzeptieren.
7. Warum verwenden? decltype In magic_apply?
8. Nutzung der Werte der std::expected Objekte, um den Rückgabetyp der aufgerufenen Funktion automatisch zu bestimmen.
9. Ist magic_apply in der Lage, verschiedene Fehlertypen zu behandeln?
10. Ja, es kann so gestaltet werden, dass es funktioniert std::expected Werte mit verschiedenen Fehlerarten mit ein paar Optimierungen.
11. Welche Vorteile bietet die Nutzung std::expected Angebot?
12. Beim Umgang mit Fehlern bietet es einen aussagekräftigeren und saubereren Ansatz als konventionellere Techniken wie Ausnahmen oder Rückkehrcodes.
13. Ist std::unexpected Teil von std::expected?
14. Zusätzlich zu std::expected, std::unexpected stellt tatsächlich einen falschen Wert dar.
15. Können asynchrone Aktionen verwendet werden? magic_apply?
16. Es ist in der Tat anpassungsfähig in der Handhabung std::expected Werte, die von asynchronen Vorgängen zurückgegeben werden.
17. Was ist ein Faltausdruck?
18. Hier wird die Funktion „Fold Expression“ in C++ verwendet, um zu überprüfen, ob alle vorhanden sind std::expected Objekte enthalten auf einfache Weise gültige Werte.

Zusammenfassung:

In C++23 verbessert die Implementierung einer generischen Funktion zur Verarbeitung mehrerer std::expected-Werte die Lesbarkeit des Codes erheblich und vereinfacht die Fehlerbehandlung erheblich. Die magic_apply-Funktion reduziert den Boilerplate-Code und verbessert die Wartbarkeit, indem sie verschiedene Vorlagen verwendet, um sicherzustellen, dass alle erwarteten Werte vor der Verarbeitung korrekt sind. Diese Methode bietet eine flexible Lösung, die auf verschiedene Situationen angewendet werden kann und der modernen C++-Programmierung eine sauberere und effektivere Möglichkeit zur Fehlerbehandlung bietet.