Folosind std::apply pe std::expected în C++23

Simplificarea gestionării erorilor în C++23

Gestionarea eficientă a greșelilor și gestionarea valorilor de returnare sunt esențiale în dezvoltarea C++ de astăzi. Metoda tipică de lucru cu funcții care returnează tipuri {std::expected} include o mulțime de verificări și cod de gestionare a erorilor, ceea ce poate complica logica și poate face codul mai dificil de întreținut.

Această lucrare investighează utilizarea unei metode mai sofisticate și mai generale pentru a simplifica gestionarea erorilor. Pentru a reduce codul standard și a îmbunătăți lizibilitatea, vom investiga construirea unei metode `magic_apply` care agrega rezultatele multor valori {std::expected} și le transmite unei alte funcții.

Comanda	Descriere
std::expected	Un tip de șablon folosit în C++ pentru tratarea erorilor, care are capacitatea de a stoca atât valori, cât și erori.
std::unexpected	Când este utilizat cu std::expected, reprezintă o valoare de eroare neașteptată.
template<typename...>	Conturează un șablon variadic cu o cantitate infinită de argumente șablon pe care le poate accepta.
decltype	Folosit în programarea șablonului, în special pentru a afla tipul de expresie.
args.value()	Dacă un obiect std::expected are o valoare, accesează valoarea conținută în el.
args.has_value()	Verifică dacă o valoare este prezentă într-un obiect std::expected.
(... && args.has_value())	Pentru a determina dacă fiecare obiect std::expected are valori, pliați expresia.
func(args.value()...)	Utilizează valorile obiectelor std::expected pentru a apela metoda func.
return unexpected<Err>(args.error()...)	Returnează o eroare neașteptată care conține erorile de la obiectele std::expected.

Gestionarea eficientă a erorilor folosind șabloane variabile

The tipul este folosit în scripturi pentru a ușura gestionarea erorilor în C++23. Scopul principal este de a dezvolta o funcție generică numită care poate transmite ieșirea mai multor valori la o altă funcție. Făcând acest lucru, obositoarea verificare a erorilor care este de obicei necesară atunci când lucrați cu mulți std::expected valorile sunt reduse. este destul de flexibil, deoarece poate dura orice număr de parametrii prin utilizarea șabloanelor variadice. Înainte de a apela funcția cu conținutul oricărei obiect, logica fundamentală a magic_apply folosește o expresie fold, , pentru a vă asigura că toate obiectele au valori valide.

Această idee este ilustrată în primul exemplu de script folosind tipuri simple, cum ar fi şi . Acesta definește a funcție care efectuează un calcul de bază și getA şi funcții care revin tipuri. Dacă ambele valori din şi getB sunt legitime, putem apela folosind ; dacă nu, eroarea este propagată. Prin reducerea codului standard, această metodă îmbunătățește lizibilitatea și mentenabilitatea. O idee similară este prezentată în al doilea scenariu, dar pentru a evidenția versatilitatea abordării, tipuri şi lambda functions sunt folosite.

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

Îmbunătățirea gestionării erorilor C++ cu șabloane Variadic

Capacitatea de a îmbunătăți considerabil gestionarea erorilor în sisteme complexe este un alt beneficiu crucial al utilizării acestuia în C++. Combinarea perfectă a rezultatelor multor acțiuni asincrone este esențială în situațiile în care acestea cedează tipuri. Pe lângă faptul că face codul mai simplu, această metodă garantează o gestionare puternică a erorilor. Funcții mai versatile și generice pot fi create prin combinarea unui număr arbitrar de valori cu variadic templates.

Versatilitatea lui permite să fie utilizat cu funcții care acceptă o varietate de tipuri de argumente. Implementarea este simplificată în continuare prin utilizarea , care deduce automat tipul de returnare al apelului de funcție combinată. În plus, această tehnică poate fi extinsă pentru a gestiona sarcini mai complicate, inclusiv fuzionarea valori cu alte tipuri de erori sau modificarea valorilor înainte de a le trimite la funcție. Datorită adaptabilității sale, modelul poate fi utilizat pentru o gamă largă de sarcini, de la calcule simple la operații complexe.

În C++23, implementarea unei funcții generice pentru a gestiona mai multe valori std::expected îmbunătățește foarte mult lizibilitatea codului și simplifică foarte mult gestionarea erorilor. Funcția magic_apply reduce codul standard și îmbunătățește menținerea prin utilizarea șabloanelor variadice pentru a vă asigura că toate valorile anticipate sunt corecte înainte de procesare. Această metodă oferă o soluție flexibilă care poate fi aplicată în diferite situații și oferă programării moderne C++ o modalitate mai curată și mai eficientă de a gestiona defecțiunile.