C++23 ರಲ್ಲಿ ನಿರೀಕ್ಷಿತ std :: std:: ಅನ್ವಯಿಸು

C++23 ರಲ್ಲಿ ಸ್ಟ್ರೀಮ್ಲೈನಿಂಗ್ ದೋಷ ನಿರ್ವಹಣೆ

ತಪ್ಪುಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು ಮತ್ತು ರಿಟರ್ನ್ ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಇಂದಿನ C++ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಅತ್ಯಗತ್ಯ. {std::expected} ಪ್ರಕಾರಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವ ಕಾರ್ಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ವಿಶಿಷ್ಟ ವಿಧಾನವು ಬಹಳಷ್ಟು ತಪಾಸಣೆಗಳು ಮತ್ತು ದೋಷ ನಿರ್ವಹಣೆ ಕೋಡ್ ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಇದು ತರ್ಕವನ್ನು ಸಂಕೀರ್ಣಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಕೋಡ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಹೆಚ್ಚು ಕಷ್ಟಕರವಾಗುತ್ತದೆ.

ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಸರಳಗೊಳಿಸಲು ಹೆಚ್ಚು ಅತ್ಯಾಧುನಿಕ ಮತ್ತು ಸಾಮಾನ್ಯ ವಿಧಾನದ ಬಳಕೆಯನ್ನು ಈ ಕಾಗದವು ತನಿಖೆ ಮಾಡುತ್ತದೆ. ಬಾಯ್ಲರ್‌ಪ್ಲೇಟ್ ಕೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಮತ್ತು ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸಲು, ಹಲವು {std::expected} ಮೌಲ್ಯಗಳ ಫಲಿತಾಂಶಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸುವ ಮತ್ತು ಅವುಗಳನ್ನು ಮತ್ತೊಂದು ಕಾರ್ಯಕ್ಕೆ ರವಾನಿಸುವ `ಮ್ಯಾಜಿಕ್_ಅಪ್ಲಿ` ವಿಧಾನವನ್ನು ನಿರ್ಮಿಸುವುದನ್ನು ನಾವು ತನಿಖೆ ಮಾಡುತ್ತೇವೆ.

ಆಜ್ಞೆ	ವಿವರಣೆ
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 ಪಟ್ಟು ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಬಳಸುತ್ತದೆ, , ಎಲ್ಲವನ್ನೂ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ವಸ್ತುಗಳು ಮಾನ್ಯವಾದ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿವೆ.

ಈ ಕಲ್ಪನೆಯನ್ನು ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್ ಉದಾಹರಣೆಯಲ್ಲಿ ಸರಳ ಪ್ರಕಾರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ವಿವರಿಸಲಾಗಿದೆ ಮತ್ತು . ಇದು ಎ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ ಮೂಲಭೂತ ಗಣನೆಯನ್ನು ಕೈಗೊಳ್ಳುವ ಕಾರ್ಯ, ಮತ್ತು 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++ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಕ್ಲೀನರ್, ವೈಫಲ್ಯಗಳನ್ನು ನಿಭಾಯಿಸಲು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತದೆ.