V C++23 se pričakuje uporaba std::apply na std::

V C++23 se pričakuje uporaba std::apply na std::
V C++23 se pričakuje uporaba std::apply na std::
Lina Fontaine
Sreda, 18. september 2024 21:25:53

Poenostavitev obravnavanja napak v C++23

Učinkovito obravnavanje napak in upravljanje vrnjenih vrednosti je bistvenega pomena pri današnjem razvoju C++. Tipičen način dela s funkcijami, ki vrnejo vrste {std::expected}, vključuje veliko preverjanj in kode za obravnavanje napak, kar lahko zaplete logiko in oteži vzdrževanje kode.

Ta članek raziskuje uporabo bolj izpopolnjene in splošne metode za poenostavitev upravljanja napak. Da bi zmanjšali standardno kodo in izboljšali berljivost, bomo raziskali izdelavo metode `magic_apply`, ki združuje rezultate številnih vrednosti {std::expected} in jih posreduje drugi funkciji.

Ukaz Opis
std::expected Vrsta predloge, ki se uporablja v C++ za obravnavanje napak in ima možnost shranjevanja vrednosti in napak.
std::unexpected Če se uporablja s std::expected, predstavlja nepričakovano vrednost napake.
template<typename...> Orisuje variatično predlogo z neskončno količino argumentov predloge, ki jih lahko sprejme.
decltype Uporablja se pri programiranju predlog, zlasti za ugotavljanje vrste izraza.
args.value() Če ima objekt std::expected vrednost, dostopa do vrednosti, ki jo vsebuje.
args.has_value() Preveri, ali je vrednost prisotna v objektu std::expected.
(... && args.has_value()) Če želite ugotoviti, ali ima vsak objekt std::expected vrednosti, zložite izraz.
func(args.value()...) Uporablja vrednosti objektov std::expected za klic metode func.
return unexpected<Err>(args.error()...) Vrne nepričakovano napako, ki vsebuje napake iz objektov std::expected.

Učinkovito upravljanje napak z uporabo spremenljivih predlog

The std::expected tip se uporablja v skriptih za olajšanje obravnavanja napak v C++23. Glavni cilj je razviti generično funkcijo, imenovano magic_apply ki lahko prenaša izhod več std::expected vrednosti v drugo funkcijo. S tem dolgočasno preverjanje napak, ki je običajno potrebno pri delu z mnogimi std::expected vrednosti se zmanjšajo. magic_apply je precej prilagodljiv, saj lahko traja poljubno število std::expected parametrov z uporabo različnih predlog. Preden pokličete funkcijo z vsebino katerega koli std::expected objekt, temeljna logika magic_apply uporablja zložljiv izraz, (... && args.has_value()), da se prepričam o vseh std::expected objekti imajo veljavne vrednosti.

Ta ideja je ponazorjena v prvem primeru skripta z uporabo preprostih tipov, kot je npr int in double. Določa a compute_all funkcija, ki izvaja osnovni izračun, in getA in getB funkcije, ki vračajo std::expected vrste. Če sta obe vrednosti iz getA in getB so legitimni, lahko pokličemo compute_all uporabo magic_apply; če ne, se napaka razširi. Z zmanjšanjem standardne kode ta metoda izboljša berljivost in vzdržljivost. Podobna zamisel je predstavljena v drugem scenariju, vendar da bi poudarili vsestranskost pristopa, string vrste in lambda functions se uporabljajo.

Zmanjšanje zapletenosti pri obravnavanju napak C++ z `std::expected}

Skript C++23 z uporabo različnih predlog

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

Združevanje različnih {std::expected} rezultatov C++23 vrednosti

Skript C++23 z uporabo lambda funkcij

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

Izboljšanje obravnave napak C++ z različnimi predlogami

Zmogljivost std::expected močno izboljšanje obravnavanja napak v zapletenih sistemih je še ena ključna prednost njegove uporabe v C++. Brezhibno združevanje rezultatov številnih asinhronih dejanj je bistvenega pomena v situacijah, ko prinašajo std::expected vrste. Poleg poenostavitve kode ta metoda zagotavlja močno obravnavo napak. Bolj vsestranske in splošne funkcije je mogoče ustvariti s kombiniranjem poljubnega števila std::expected vrednosti z variadic templates.

Vsestranskost magic_apply omogoča uporabo s funkcijami, ki sprejemajo različne vrste argumentov. Izvedba je dodatno poenostavljena z uporabo decltype, ki samodejno izpelje povratni tip kombiniranega klica funkcije. Poleg tega je to tehniko mogoče razširiti za upravljanje bolj zapletenih nalog, vključno z združevanjem std::expected vrednosti z drugimi vrstami napak ali spreminjanje vrednosti, preden jih pošljete funkciji. Zaradi svoje prilagodljivosti se vzorec lahko uporablja za širok spekter nalog, od enostavnih izračunov do kompleksnih operacij.

Pogosto zastavljena vprašanja o variadičnih predlogah in std::expected

  1. Kaj je std::expected?
  2. To je tip predloge C++, ki lahko vsebuje napako ali veljavno vrednost in se uporablja za upravljanje napak.
  3. Kako magic_apply delo?
  4. Odpravlja potrebo po ponavljajočih se preverjanjih napak, saj združuje rezultate številnih std::expected vrednosti in jih posreduje funkciji.
  5. Kaj so spremenljive predloge?
  6. Predloge spremenljivk ponujajo veliko mero svobode pri oblikovanju funkcij, saj funkcijam omogočajo, da sprejmejo poljubno število parametrov.
  7. Zakaj uporabljati decltype v magic_apply?
  8. Z uporabo vrednot std::expected objekte za samodejno določanje vrste povratka klicane funkcije.
  9. je magic_apply sposobni obravnavati različne vrste napak?
  10. Da, z njim se da delovati std::expected vrednosti, ki imajo različne vrste napak z nekaj prilagoditvami.
  11. Kakšne prednosti ima uporaba std::expected ponudba?
  12. Pri obravnavanju napak ponuja bolj izrazit in čistejši pristop kot pri bolj običajnih tehnikah, kot so izjeme ali povratne kode.
  13. je std::unexpected del std::expected?
  14. Poleg std::expected, std::unexpected dejansko predstavlja nepravilno vrednost.
  15. Ali je mogoče uporabiti asinhrona dejanja z magic_apply?
  16. Res je prilagodljiv za rokovanje std::expected vrednosti, ki jih vrnejo asinhrone operacije.
  17. Kaj je pregibni izraz?
  18. Tu se funkcija v C++, imenovana pregibni izraz, uporablja za preverjanje, ali so vsi std::expected predmeti vsebujejo veljavne vrednosti na preprost način.

Zaključek:

V C++23 implementacija generične funkcije za obravnavanje več std::expected vrednosti močno izboljša berljivost kode in močno poenostavi obravnavanje napak. Funkcija magic_apply zmanjša standardno kodo in izboljša vzdržljivost z uporabo različnih predlog, da zagotovi, da so vse pričakovane vrednosti pred obdelavo pravilne. Ta metoda ponuja prilagodljivo rešitev, ki jo je mogoče uporabiti v različnih situacijah, in daje sodobnemu programiranju C++ čistejši in učinkovitejši način za obravnavo napak.