C++23-ൽ പ്രതീക്ഷിക്കുന്ന std::std:: പ്രയോഗിക്കുക

C++23-ൽ സ്ട്രീംലൈനിംഗ് പിശക് കൈകാര്യം ചെയ്യുന്നു

തെറ്റുകൾ ഫലപ്രദമായി കൈകാര്യം ചെയ്യുന്നതും റിട്ടേൺ മൂല്യങ്ങൾ കൈകാര്യം ചെയ്യുന്നതും ഇന്നത്തെ C++ വികസനത്തിൽ അത്യന്താപേക്ഷിതമാണ്. {std::expected} തരങ്ങൾ നൽകുന്ന ഫംഗ്‌ഷനുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള സാധാരണ രീതിയിൽ ധാരാളം പരിശോധനകളും പിശക് കൈകാര്യം ചെയ്യുന്നതിനുള്ള കോഡും ഉൾപ്പെടുന്നു, ഇത് യുക്തിയെ സങ്കീർണ്ണമാക്കുകയും കോഡ് പരിപാലിക്കുന്നത് കൂടുതൽ ബുദ്ധിമുട്ടാക്കുകയും ചെയ്യും.

പിശക് മാനേജ്മെൻ്റ് ലളിതമാക്കുന്നതിന് കൂടുതൽ സങ്കീർണ്ണവും പൊതുവായതുമായ രീതിയുടെ ഉപയോഗം ഈ പേപ്പർ അന്വേഷിക്കുന്നു. ബോയിലർപ്ലേറ്റ് കോഡ് കുറയ്ക്കുന്നതിനും വായനാക്ഷമത മെച്ചപ്പെടുത്തുന്നതിനും, നിരവധി {std::expected} മൂല്യങ്ങളുടെ ഫലങ്ങൾ സമാഹരിച്ച് മറ്റൊരു ഫംഗ്‌ഷനിലേക്ക് കൈമാറുന്ന ഒരു `magic_apply` രീതി നിർമ്മിക്കുന്നത് ഞങ്ങൾ അന്വേഷിക്കും.

കമാൻഡ്	വിവരണം
std::expected	മൂല്യങ്ങളും പിശകുകളും സംഭരിക്കാനുള്ള കഴിവുള്ള പിശക് കൈകാര്യം ചെയ്യുന്നതിനായി C++ ൽ ഉപയോഗിക്കുന്ന ഒരു ടെംപ്ലേറ്റ് തരം.
std::unexpected	std::expected ഉപയോഗിച്ച് ഉപയോഗിക്കുമ്പോൾ, ഒരു അപ്രതീക്ഷിത പിശക് മൂല്യത്തെ പ്രതിനിധീകരിക്കുന്നു.
template<typename...>	അനന്തമായ അളവിലുള്ള ടെംപ്ലേറ്റ് ആർഗ്യുമെൻ്റുകളുള്ള ഒരു വ്യത്യസ്‌ത ടെംപ്ലേറ്റിൻ്റെ രൂപരേഖ നൽകുന്നു.
decltype	ടെംപ്ലേറ്റ് പ്രോഗ്രാമിംഗിൽ, പ്രത്യേകിച്ച് എക്സ്പ്രഷൻ തരം കണ്ടെത്താൻ ഉപയോഗിക്കുന്നു.
args.value()	ഒരു std:: പ്രതീക്ഷിക്കുന്ന ഒബ്‌ജക്റ്റിന് ഒരു മൂല്യമുണ്ടെങ്കിൽ, അതിൽ അടങ്ങിയിരിക്കുന്ന മൂല്യം ആക്‌സസ് ചെയ്യുന്നു.
args.has_value()	ഒരു std:: പ്രതീക്ഷിക്കുന്ന ഒബ്‌ജക്റ്റിൽ ഒരു മൂല്യം ഉണ്ടോ എന്ന് പരിശോധിക്കുന്നു.
(... && args.has_value())	ഓരോ std:: പ്രതീക്ഷിക്കുന്ന ഒബ്ജക്റ്റിനും മൂല്യങ്ങളുണ്ടോ എന്ന് നിർണ്ണയിക്കാൻ, എക്സ്പ്രഷൻ മടക്കിക്കളയുക.
func(args.value()...)	രീതിയെ ഫങ്ക് എന്ന് വിളിക്കാൻ std:: പ്രതീക്ഷിക്കുന്ന ഒബ്‌ജക്റ്റുകളുടെ മൂല്യങ്ങൾ ഉപയോഗിക്കുന്നു.
return unexpected<Err>(args.error()...)	std:: പ്രതീക്ഷിച്ച ഒബ്‌ജക്‌റ്റുകളിൽ നിന്നുള്ള പിശകുകൾ അടങ്ങിയ ഒരു അപ്രതീക്ഷിത പിശക് നൽകുന്നു.

വേരിയബിൾ ടെംപ്ലേറ്റുകൾ ഉപയോഗിച്ചുള്ള ഫലപ്രദമായ പിശക് മാനേജ്മെൻ്റ്

ദി C++23-ൽ പിശക് കൈകാര്യം ചെയ്യാൻ സ്ക്രിപ്റ്റുകളിൽ തരം ഉപയോഗിക്കുന്നു. എന്ന ഒരു പൊതു പ്രവർത്തനം വികസിപ്പിക്കുക എന്നതാണ് പ്രധാന ലക്ഷ്യം അതിന് പലതിൻ്റെയും ഔട്ട്പുട്ട് കൈമാറാൻ കഴിയും മറ്റൊരു ഫംഗ്‌ഷനിലേക്കുള്ള മൂല്യങ്ങൾ. ഇത് ചെയ്യുന്നതിലൂടെ, പലരുമായും പ്രവർത്തിക്കുമ്പോൾ സാധാരണയായി ആവശ്യമായ മടുപ്പിക്കുന്ന പിശക് പരിശോധന std::expected മൂല്യങ്ങൾ കുറയുന്നു. ഇത് തികച്ചും വഴക്കമുള്ളതാണ്, കാരണം ഇതിന് എത്ര വേണമെങ്കിലും എടുത്തേക്കാം വേരിയാഡിക് ടെംപ്ലേറ്റുകൾ ഉപയോഗിച്ച് പരാമീറ്ററുകൾ. ഏതെങ്കിലും ഉള്ളടക്കം ഉപയോഗിച്ച് ഫംഗ്ഷൻ വിളിക്കുന്നതിന് മുമ്പ് വസ്തു, അടിസ്ഥാന യുക്തി magic_apply ഒരു ഫോൾഡ് എക്സ്പ്രഷൻ ഉപയോഗിക്കുന്നു, , എല്ലാം ഉറപ്പാക്കാൻ വസ്തുക്കൾക്ക് സാധുവായ മൂല്യങ്ങളുണ്ട്.

പോലുള്ള ലളിതമായ തരങ്ങൾ ഉപയോഗിച്ച് ഈ ആശയം ആദ്യ സ്ക്രിപ്റ്റ് ഉദാഹരണത്തിൽ ചിത്രീകരിച്ചിരിക്കുന്നു ഒപ്പം . അത് നിർവ്വചിക്കുന്നു a ഒരു അടിസ്ഥാന കണക്കുകൂട്ടൽ നടത്തുന്ന പ്രവർത്തനം, കൂടാതെ getA ഒപ്പം തിരികെ നൽകുന്ന പ്രവർത്തനങ്ങൾ തരങ്ങൾ. രണ്ട് മൂല്യങ്ങളും ആണെങ്കിൽ ഒപ്പം getB നിയമാനുസൃതമാണ്, നമുക്ക് വിളിക്കാം ഉപയോഗിക്കുന്നത് ; ഇല്ലെങ്കിൽ, തെറ്റ് പ്രചരിപ്പിക്കുന്നു. ബോയിലർ പ്ലേറ്റ് കോഡ് കുറയ്ക്കുന്നതിലൂടെ, ഈ രീതി വായനാക്ഷമതയും പരിപാലനവും വർദ്ധിപ്പിക്കുന്നു. സമാനമായ ഒരു ആശയം രണ്ടാമത്തെ സ്ക്രിപ്റ്റിൽ അവതരിപ്പിച്ചിരിക്കുന്നു, എന്നാൽ സമീപനത്തിൻ്റെ ബഹുമുഖത ഉയർത്തിക്കാട്ടാൻ, തരങ്ങളും lambda functions ഉപയോഗിക്കുന്നു.

#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++ പിശക് കൈകാര്യം ചെയ്യൽ മെച്ചപ്പെടുത്തുന്നു

യുടെ ശേഷി സങ്കീർണ്ണമായ സിസ്റ്റങ്ങളിൽ പിശക് കൈകാര്യം ചെയ്യൽ വളരെയധികം വർദ്ധിപ്പിക്കുക എന്നത് C++-ൽ ഇത് ഉപയോഗിക്കുന്നതിൻ്റെ മറ്റൊരു നിർണായക നേട്ടമാണ്. പല അസിൻക്രണസ് പ്രവർത്തനങ്ങളുടെയും ഫലങ്ങൾ തടസ്സമില്ലാതെ സംയോജിപ്പിക്കുന്നത് അവ ഫലം നൽകുന്ന സാഹചര്യങ്ങളിൽ അത്യന്താപേക്ഷിതമാണ് തരങ്ങൾ. കോഡ് ലളിതമാക്കുന്നതിനു പുറമേ, ഈ രീതി ശക്തമായ പിശക് കൈകാര്യം ചെയ്യൽ ഉറപ്പ് നൽകുന്നു. ഒരു ഏകപക്ഷീയമായ സംഖ്യ സംയോജിപ്പിച്ച് കൂടുതൽ ബഹുമുഖവും പൊതുവായതുമായ ഫംഗ്ഷനുകൾ സൃഷ്ടിക്കാൻ കഴിയും കൂടെ മൂല്യങ്ങൾ variadic templates.

എന്ന ബഹുമുഖത വിവിധ ആർഗ്യുമെൻ്റ് തരങ്ങൾ എടുക്കുന്ന ഫംഗ്ഷനുകൾക്കൊപ്പം ഇത് ഉപയോഗിക്കാൻ അനുവദിക്കുന്നു. ഉപയോഗിച്ച് നടപ്പിലാക്കുന്നത് കൂടുതൽ ലളിതമാക്കുന്നു , ഇത് സംയോജിത ഫംഗ്‌ഷൻ കോളിൻ്റെ റിട്ടേൺ തരം സ്വയമേവ കുറയ്ക്കുന്നു. കൂടാതെ, ലയിപ്പിക്കുന്നതുൾപ്പെടെ കൂടുതൽ സങ്കീർണ്ണമായ ജോലികൾ കൈകാര്യം ചെയ്യുന്നതിനായി ഈ സാങ്കേതികവിദ്യ വിപുലീകരിക്കാവുന്നതാണ് മറ്റ് പിശക് തരങ്ങളുള്ള മൂല്യങ്ങൾ അല്ലെങ്കിൽ ഫംഗ്‌ഷനിലേക്ക് അയയ്‌ക്കുന്നതിന് മുമ്പ് മൂല്യങ്ങളിൽ മാറ്റം വരുത്തുക. അതിൻ്റെ അഡാപ്റ്റബിലിറ്റി കാരണം, ലളിതമായ കണക്കുകൂട്ടലുകൾ മുതൽ സങ്കീർണ്ണമായ പ്രവർത്തനങ്ങൾ വരെ വിശാലമായ ജോലികൾക്കായി പാറ്റേൺ ഉപയോഗിക്കാം.

C++23-ൽ, ഒന്നിലധികം std:: പ്രതീക്ഷിക്കുന്ന മൂല്യങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു ജനറിക് ഫംഗ്‌ഷൻ നടപ്പിലാക്കുന്നത് കോഡ് റീഡബിലിറ്റിയെ വളരെയധികം മെച്ചപ്പെടുത്തുകയും പിശക് കൈകാര്യം ചെയ്യുന്നത് വളരെ ലളിതമാക്കുകയും ചെയ്യുന്നു. മാജിക്_അപ്ലൈ ഫംഗ്‌ഷൻ ബോയിലർപ്ലേറ്റ് കോഡ് കുറയ്ക്കുകയും പ്രോസസ്സ് ചെയ്യുന്നതിന് മുമ്പ് പ്രതീക്ഷിക്കുന്ന എല്ലാ മൂല്യങ്ങളും ശരിയാണെന്ന് ഉറപ്പാക്കാൻ വേരിയാഡിക് ടെംപ്ലേറ്റുകൾ ഉപയോഗിച്ച് പരിപാലനക്ഷമത വർദ്ധിപ്പിക്കുകയും ചെയ്യുന്നു. ഈ രീതി വ്യത്യസ്ത സാഹചര്യങ്ങളിൽ പ്രയോഗിക്കാൻ കഴിയുന്ന ഒരു വഴക്കമുള്ള പരിഹാരം വാഗ്ദാനം ചെയ്യുന്നു കൂടാതെ ആധുനിക C++ പ്രോഗ്രാമിംഗ് പരാജയങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള വൃത്തിയുള്ളതും കൂടുതൽ ഫലപ്രദവുമായ മാർഗ്ഗം നൽകുന്നു.