Utilitzant std::apply a std::expected a C++23

Reducció de la complexitat en la gestió d'errors de C++ amb `std::expected}

Script C++23 utilitzant plantilles variàdiques

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

Combinant diferents valors de resultats de {std::expected} C++23

Script C++23 utilitzant funcions 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;
}

Preguntes freqüents sobre Plantilles Variadic i std::expected

1. Què és std::expected?
2. És un tipus de plantilla C++ que pot contenir un error o un valor vàlid i s'utilitza per a la gestió d'errors.
3. Com ho fa magic_apply treballar?
4. Elimina la necessitat de comprovacions repetides d'errors combinant els resultats de nombrosos std::expected valors i passar-los a una funció.
5. Què són les plantilles variàdiques?
6. Les plantilles variables ofereixen una gran llibertat en el disseny de funcions, ja que permeten que les funcions acceptin un nombre arbitrari de paràmetres.
7. Per què utilitzar decltype en magic_apply?
8. Utilitzant els valors de la std::expected objectes per determinar automàticament el tipus de retorn de la funció que es crida.
9. És magic_apply capaç de gestionar diversos tipus d'error?
10. Sí, es pot fer que funcioni std::expected valors que tenen diversos tipus d'error amb alguns ajustaments.
11. Quins avantatges té utilitzar std::expected oferta?
12. Quan es tracta d'errors, ofereix un enfocament més expressiu i més net que amb tècniques més convencionals com les excepcions o els codis de retorn.
13. És std::unexpected part de std::expected?
14. A més de std::expected, std::unexpected de fet, representa un valor incorrecte.
15. Es poden utilitzar accions asíncrones amb magic_apply?
16. De fet, és adaptable al maneig std::expected valors retornats per operacions asíncrones.
17. Què és una expressió de plec?
18. Aquí, la característica en C++ anomenada expressió de plec s'utilitza per comprovar si tot std::expected els objectes contenen valors vàlids d'una manera senzilla.

Conclusió:

En C++23, la implementació d'una funció genèrica per gestionar diversos valors std::esperats millora molt la llegibilitat del codi i simplifica molt el maneig d'errors. La funció magic_apply redueix el codi normal i millora el manteniment mitjançant l'ús de plantilles variades per assegurar-se que tots els valors previstos són correctes abans de processar-los. Aquest mètode ofereix una solució flexible que es pot aplicar a diferents situacions i ofereix a la programació C++ moderna una manera més neta i eficaç de gestionar els errors.