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

`std::expected} ഉപയോഗിച്ച് C++ പിശക് കൈകാര്യം ചെയ്യുന്നതിൽ സങ്കീർണ്ണത കുറയ്ക്കുന്നു

C++23 സ്‌ക്രിപ്റ്റ് വാരിയാഡിക് ടെംപ്ലേറ്റുകൾ ഉപയോഗിക്കുന്നു

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

വ്യത്യസ്ത {std::expected} ഫലങ്ങൾ സംയോജിപ്പിക്കുന്നു C++23 മൂല്യങ്ങൾ

ലാംഡ ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുന്ന C++23 സ്‌ക്രിപ്റ്റ്

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

വേരിയാഡിക് ടെംപ്ലേറ്റുകളെക്കുറിച്ചും std:: പ്രതീക്ഷിക്കുന്നതിനെക്കുറിച്ചും പതിവായി ചോദിക്കുന്ന ചോദ്യങ്ങൾ

1. എന്താണ് std::expected?
2. ഇത് ഒരു C++ ടെംപ്ലേറ്റ് തരമാണ്, അത് ഒരു പിശക് അല്ലെങ്കിൽ ഒരു സാധുവായ മൂല്യം നിലനിർത്താൻ കഴിയും, അത് പിശക് മാനേജ്മെൻ്റിനായി ഉപയോഗിക്കുന്നു.
3. എങ്ങനെ ചെയ്യുന്നു magic_apply ജോലി?
4. നിരവധി ഫലങ്ങൾ സംയോജിപ്പിച്ച് ആവർത്തിച്ചുള്ള പിശക് പരിശോധനകളുടെ ആവശ്യകത ഇത് ഇല്ലാതാക്കുന്നു std::expected മൂല്യങ്ങളും അവയെ ഒരു ഫംഗ്ഷനിലേക്ക് കൈമാറുന്നു.
5. വേരിയാഡിക് ടെംപ്ലേറ്റുകൾ എന്തൊക്കെയാണ്?
6. അനിയന്ത്രിതമായ എണ്ണം പാരാമീറ്ററുകൾ സ്വീകരിക്കാൻ ഫംഗ്‌ഷനുകളെ പ്രാപ്‌തമാക്കുന്നതിലൂടെ വേരിയബിൾ ടെംപ്ലേറ്റുകൾ ഫംഗ്‌ഷൻ രൂപകൽപ്പനയിൽ വലിയൊരു സ്വാതന്ത്ര്യം വാഗ്ദാനം ചെയ്യുന്നു.
7. എന്തിനാണ് ഉപയോഗിക്കുന്നത് decltype ഇൻ magic_apply?
8. മൂല്യങ്ങൾ ഉപയോഗപ്പെടുത്തുന്നു std::expected വിളിക്കപ്പെടുന്ന ഫംഗ്‌ഷൻ്റെ റിട്ടേൺ തരം സ്വയമേവ നിർണ്ണയിക്കാൻ ഒബ്‌ജക്റ്റുകൾ.
9. ആണ് magic_apply വിവിധ തരത്തിലുള്ള പിശകുകൾ കൈകാര്യം ചെയ്യാൻ കഴിയുമോ?
10. അതെ, ഇത് ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ കഴിയും std::expected കുറച്ച് ട്വീക്കുകൾ ഉപയോഗിച്ച് വ്യത്യസ്ത തരത്തിലുള്ള പിശകുകളുള്ള മൂല്യങ്ങൾ.
11. എന്ത് നേട്ടങ്ങളാണ് ഉപയോഗിക്കുന്നത് std::expected ഓഫർ?
12. തെറ്റുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ, ഒഴിവാക്കലുകൾ അല്ലെങ്കിൽ റിട്ടേൺ കോഡുകൾ പോലുള്ള കൂടുതൽ പരമ്പരാഗത സാങ്കേതികതകളേക്കാൾ കൂടുതൽ പ്രകടവും വൃത്തിയുള്ളതുമായ സമീപനം ഇത് വാഗ്ദാനം ചെയ്യുന്നു.
13. ആണ് std::unexpected ഭാഗം std::expected?
14. ഇതിനുപുറമെ std::expected, std::unexpected വാസ്തവത്തിൽ, ഒരു തെറ്റായ മൂല്യത്തെ പ്രതിനിധീകരിക്കുന്നു.
15. അസിൻക്രണസ് പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കാനാകുമോ? magic_apply?
16. ഇത് തീർച്ചയായും കൈകാര്യം ചെയ്യാൻ അനുയോജ്യമാണ് std::expected അസിൻക്രണസ് ഓപ്പറേഷനുകൾ നൽകുന്ന മൂല്യങ്ങൾ.
17. ഒരു ഫോൾഡ് എക്സ്പ്രഷൻ എന്താണ്?
18. ഇവിടെ, C++ ലെ ഫോൾഡ് എക്സ്പ്രഷൻ എന്ന ഫീച്ചർ എല്ലാം ഉണ്ടോ എന്ന് പരിശോധിക്കാൻ ഉപയോഗിക്കുന്നു std::expected ഒബ്‌ജക്‌റ്റുകൾ ലളിതമായ രീതിയിൽ സാധുവായ മൂല്യങ്ങൾ ഉൾക്കൊള്ളുന്നു.

പൊതിയുന്നു:

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