Použitie std::apply na std::očakávané v C++23

Zjednodušenie spracovania chýb v C++23

Efektívne zvládanie chýb a riadenie návratových hodnôt je v dnešnom vývoji C++ nevyhnutné. Typická metóda práce s funkciami, ktoré vracajú typy {std::expected}, zahŕňa množstvo kontrol a kódov na spracovanie chýb, čo môže skomplikovať logiku a sťažiť údržbu kódu.

Tento dokument skúma použitie sofistikovanejšej a všeobecnejšej metódy na zjednodušenie správy chýb. Aby sme znížili štandardný kód a zlepšili čitateľnosť, preskúmame vytvorenie metódy `magic_apply`, ktorá agreguje výsledky mnohých {std::expected} hodnôt a odovzdá ich inej funkcii.

Príkaz	Popis
std::expected	Typ šablóny používaný v C++ na spracovanie chýb, ktorý má schopnosť ukladať hodnoty aj chyby.
std::unexpected	Pri použití s ​​std::expected predstavuje neočakávanú chybovú hodnotu.
template<typename...>	Načrtáva variadickú šablónu s nekonečným množstvom argumentov šablóny, ktoré môže akceptovať.
decltype	Používa sa pri programovaní šablón, najmä na zistenie typu výrazu.
args.value()	Ak má std::očakávaný objekt hodnotu, pristupuje k hodnote v ňom obsiahnutej.
args.has_value()	Overuje, či je v objekte std::očakávaná hodnota prítomná.
(... && args.has_value())	Ak chcete zistiť, či má každý std::očakávaný objekt hodnoty, zložte výraz.
func(args.value()...)	Používa hodnoty objektov std::expected na volanie metódy func.
return unexpected<Err>(args.error()...)	Vráti neočakávanú chybu obsahujúcu chyby z std::očakávaných objektov.

Efektívna správa chýb pomocou variabilných šablón

The typ sa používa v skriptoch na uľahčenie spracovania chýb v C++23. Hlavným cieľom je vyvinúť generickú funkciu tzv ktoré môžu prenášať výstup niekoľkých hodnoty do inej funkcie. Tým je zdĺhavá kontrola chýb, ktorá je zvyčajne potrebná pri práci s mnohými std::expected hodnoty sú znížené. je dosť flexibilný, pretože môže trvať ľubovoľný počet parametrov pomocou variadic šablón. Pred volaním funkcie s obsahom ľubovoľného objekt, základná logika magic_apply používa zložený výraz, , aby sme sa uistili, že všetko objekty majú platné hodnoty.

Táto myšlienka je ilustrovaná v prvom príklade skriptu pomocou jednoduchých typov ako napr a . Definuje a funkciu, ktorá vykonáva základný výpočet, a getA a funkcie, ktoré sa vracajú typy. Ak obe hodnoty z a getB sú legitímne, môžeme zavolať pomocou ; ak nie, chyba sa šíri. Znížením štandardného kódu táto metóda zlepšuje čitateľnosť a udržiavateľnosť. Podobná myšlienka je prezentovaná v druhom scenári, ale aby sa zdôraznila všestrannosť prístupu, typy a lambda functions sa používajú.

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

Zlepšenie spracovania chýb v C++ pomocou variadických šablón

Kapacita Výrazné zlepšenie spracovania chýb v zložitých systémoch je ďalšou zásadnou výhodou jeho použitia v C++. Bezproblémová kombinácia výsledkov mnohých asynchrónnych akcií je nevyhnutná v situáciách, keď prinášajú výsledky typy. Okrem zjednodušenia kódu táto metóda zaručuje silné spracovanie chýb. Kombináciou ľubovoľného počtu je možné vytvoriť všestrannejšie a všeobecnejšie funkcie hodnoty s variadic templates.

Všestrannosť umožňuje jeho použitie s funkciami, ktoré prijímajú rôzne druhy argumentov. Implementácia je ďalej jednoduchšia využitím , ktorý automaticky odvodí návratový typ volania kombinovanej funkcie. Okrem toho je možné túto techniku ​​rozšíriť na zvládnutie zložitejších úloh vrátane zlučovania hodnoty s inými druhmi chýb alebo zmenou hodnôt pred ich odoslaním do funkcie. Vďaka svojej prispôsobivosti môže byť vzor použitý pre širokú škálu úloh, od jednoduchých výpočtov až po zložité operácie.

V C++23 implementácia generickej funkcie na spracovanie viacerých std::očakávaných hodnôt výrazne zlepšuje čitateľnosť kódu a výrazne zjednodušuje spracovanie chýb. Funkcia magic_apply znižuje štandardný kód a zlepšuje udržiavateľnosť pomocou variadic šablón, aby sa pred spracovaním ubezpečil, že všetky predpokladané hodnoty sú správne. Táto metóda ponúka flexibilné riešenie, ktoré možno použiť v rôznych situáciách a poskytuje modernému programovaniu v C++ čistejší a efektívnejší spôsob riešenia porúch.