Izmantojot std::apply uz std::paredzēts C++23

Kļūdu apstrādes racionalizēšana programmā C++23

Mūsdienu C++ attīstībā būtiska ir efektīva kļūdu apstrāde un atdeves vērtību pārvaldība. Tipiskā metode darbam ar funkcijām, kas atgriež {std::expected} veidus, ietver daudzas pārbaudes un kļūdu apstrādes kodu, kas var sarežģīt loģiku un apgrūtināt koda uzturēšanu.

Šajā rakstā ir pētīta sarežģītākas un vispārīgākas metodes izmantošana kļūdu pārvaldības vienkāršošanai. Lai samazinātu standarta kodu un uzlabotu lasāmību, mēs izpētīsim, kā izveidot metodi "magic_apply", kas apkopo daudzu {std::expected} vērtību rezultātus un nodod tos citai funkcijai.

Komanda	Apraksts
std::expected	Veidnes veids, ko izmanto C++ kļūdu apstrādei, kas spēj saglabāt gan vērtības, gan kļūdas.
std::unexpected	Lietojot kopā ar std::expected, apzīmē neparedzētas kļūdas vērtību.
template<typename...>	Iezīmē mainīgu veidni ar bezgalīgu skaitu veidnes argumentu, ko tā var pieņemt.
decltype	Izmanto veidņu programmēšanā, īpaši, lai noskaidrotu izteiksmes veidu.
args.value()	Ja objektam std::expected ir vērtība, tas piekļūst tajā ietvertajai vērtībai.
args.has_value()	Pārbauda, ​​vai std::expected objektā ir vērtība.
(... && args.has_value())	Lai noteiktu, vai katram std::expected objektam ir vērtības, salokiet izteiksmi.
func(args.value()...)	Izmanto std::expected objektu vērtības, lai izsauktu metodi func.
return unexpected<Err>(args.error()...)	Atgriež neparedzētu kļūdu, kas satur kļūdas no std::expected objektiem.

Efektīva kļūdu pārvaldība, izmantojot mainīgās veidnes

The tips tiek izmantots skriptos, lai atvieglotu kļūdu apstrādi programmā C++23. Galvenais mērķis ir izstrādāt vispārēju funkciju, ko sauc kas var pārraidīt vairāku izvadi vērtības citai funkcijai. To darot, nogurdinošā kļūdu pārbaude, kas parasti ir nepieciešama, strādājot ar daudziem std::expected vērtības tiek samazinātas. ir diezgan elastīgs, jo tas var aizņemt jebkuru skaitu parametrus, izmantojot mainīgas veidnes. Pirms funkcijas izsaukšanas ar saturu jebkura objekts, pamatloģika magic_apply izmanto locījuma izteiksmi, , lai pārliecinātos, ka viss objektiem ir derīgas vērtības.

Šī ideja ir ilustrēta pirmajā skripta piemērā, izmantojot vienkāršus veidus, piemēram, un . Tas definē a funkcija, kas veic pamata aprēķinu, un getA un funkcijas, kas atgriežas veidi. Ja abas vērtības no un getB ir likumīgi, mēs varam piezvanīt izmantojot ; ja nē, kļūda tiek izplatīta. Samazinot standarta kodu, šī metode uzlabo lasāmību un apkopi. Līdzīga ideja ir parādīta otrajā scenārijā, taču, lai uzsvērtu pieejas daudzpusību, veidi un lambda functions tiek izmantoti.

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

C++ kļūdu apstrādes uzlabošana ar variadic veidnēm

Jauda no ievērojami uzlabot kļūdu apstrādi sarežģītās sistēmās ir vēl viens būtisks ieguvums, to izmantojot C++. Daudzu asinhrono darbību rezultātu nevainojami apvienošana ir būtiska situācijās, kad tās dod rezultātus veidi. Šī metode ne tikai padara kodu vienkāršāku, bet arī garantē spēcīgu kļūdu apstrādi. Daudzpusīgākas un vispārīgākas funkcijas var izveidot, apvienojot patvaļīgu skaitu vērtības ar variadic templates.

Daudzpusība ļauj to izmantot ar funkcijām, kas uzņem dažādu veidu argumentus. Ieviešanu vēl vairāk padara vienkāršāku, izmantojot , kas automātiski secina kombinētās funkcijas izsaukuma atgriešanas veidu. Turklāt šo paņēmienu var paplašināt, lai pārvaldītu sarežģītākus uzdevumus, tostarp apvienošanu vērtības ar citiem kļūdu veidiem vai vērtību mainīšana pirms to nosūtīšanas funkcijai. Pateicoties tās pielāgojamībai, modeli var izmantot dažādiem uzdevumiem, sākot no vienkāršiem aprēķiniem līdz sarežģītām darbībām.

Programmā C++23 vispārējas funkcijas ieviešana, lai apstrādātu vairākas std::expected vērtības, ievērojami uzlabo koda lasāmību un ievērojami vienkāršo kļūdu apstrādi. Funkcija magic_apply samazina standarta kodu un uzlabo apkopi, izmantojot dažādas veidnes, lai pirms apstrādes pārliecinātos, ka visas paredzamās vērtības ir pareizas. Šī metode piedāvā elastīgu risinājumu, ko var izmantot dažādās situācijās, un nodrošina modernu C++ programmēšanu tīrāku un efektīvāku veidu, kā tikt galā ar kļūmēm.