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

Folosind std::apply pe std::expected în C++23
Folosind std::apply pe std::expected în C++23
Lina Fontaine
Miercuri, 18 septembrie 2024, 21:11:45

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 std::expected 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ă magic_apply care poate transmite ieșirea mai multor std::expected 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. magic_apply este destul de flexibil, deoarece poate dura orice număr de std::expected parametrii prin utilizarea șabloanelor variadice. Înainte de a apela funcția cu conținutul oricărei std::expected obiect, logica fundamentală a magic_apply folosește o expresie fold, (... && args.has_value()), pentru a vă asigura că toate std::expected obiectele au valori valide.

Această idee este ilustrată în primul exemplu de script folosind tipuri simple, cum ar fi int şi double. Acesta definește a compute_all funcție care efectuează un calcul de bază și getA şi getB funcții care revin std::expected tipuri. Dacă ambele valori din getA şi getB sunt legitime, putem apela compute_all folosind magic_apply; 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, string tipuri şi lambda functions sunt folosite.

Reducerea complexității în gestionarea erorilor C++ cu `std::expected}

Script C++23 folosind șabloane variadice

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

Combinarea diferitelor valori {std::expected} rezultate C++23

Script C++23 folosind funcții 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;
}

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

Capacitatea de std::expected 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ă std::expected 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 std::expected valori cu variadic templates.

Versatilitatea lui magic_apply permite să fie utilizat cu funcții care acceptă o varietate de tipuri de argumente. Implementarea este simplificată în continuare prin utilizarea decltype, 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 std::expected 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.

Întrebări frecvente despre șabloanele Variadic și std::expected

  1. Ce este std::expected?
  2. Este un tip de șablon C++ care poate conține o eroare sau o valoare validă și este utilizat pentru gestionarea erorilor.
  3. Cum face magic_apply lucru?
  4. Elimină necesitatea verificărilor repetate ale erorilor, combinând rezultatele a numeroase std::expected valori și transmiterea lor unei funcții.
  5. Ce sunt șabloanele variadice?
  6. Șabloanele variabile oferă o mare libertate în proiectarea funcțiilor, permițând funcțiilor să accepte un număr arbitrar de parametri.
  7. De ce folosi decltype în magic_apply?
  8. Folosind valorile std::expected obiecte pentru a determina automat tipul de returnare al funcției apelate.
  9. este magic_apply capabil să gestioneze diferite tipuri de erori?
  10. Da, poate fi făcut să funcționeze cu std::expected valori cu diferite tipuri de erori cu câteva modificări.
  11. Ce avantaje are utilizarea std::expected oferi?
  12. Atunci când gestionați greșeli, oferă o abordare mai expresivă și mai curată decât cu tehnici mai convenționale, cum ar fi excepțiile sau codurile de returnare.
  13. este std::unexpected parte din std::expected?
  14. În plus față de std::expected, std::unexpected reprezintă, de fapt, o valoare incorectă.
  15. Pot fi utilizate acțiunile asincrone cu magic_apply?
  16. Este într-adevăr adaptabil la manevrare std::expected valorile returnate de operații asincrone.
  17. Ce este o expresie pliabilă?
  18. Aici, caracteristica din C++ numită expresie de pliere este folosită pentru a verifica dacă sunt toate std::expected obiectele conțin valori valide într-un mod simplu.

Încheiere:

Î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.