C++23 இல் எதிர்பார்க்கப்படும் std::std::ஐப் பயன்படுத்துதல்

சி++23ல் கையாளுவதில் ஸ்டிரீம்லைனிங் பிழை

தவறுகளை திறம்பட கையாள்வதும், வருவாய் மதிப்புகளை நிர்வகிப்பதும் இன்றைய சி++ வளர்ச்சியில் இன்றியமையாதது. {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++ இல் பயன்படுத்துவதன் மற்றொரு முக்கியமான நன்மையாகும். பல ஒத்திசைவற்ற செயல்களின் முடிவுகளை தடையின்றி இணைப்பது, அவை பலனளிக்கும் சூழ்நிலைகளில் அவசியம் வகைகள். குறியீட்டை எளிமையாக்குவதற்கு கூடுதலாக, இந்த முறை வலுவான பிழை கையாளுதலுக்கு உத்தரவாதம் அளிக்கிறது. தன்னிச்சையான எண்ணை இணைப்பதன் மூலம் மேலும் பல்துறை மற்றும் பொதுவான செயல்பாடுகளை உருவாக்க முடியும் உடன் மதிப்புகள் variadic templates.

பன்முகத்தன்மை இது பல்வேறு வகையான வாதங்களை எடுக்கும் செயல்பாடுகளுடன் பயன்படுத்த அனுமதிக்கிறது. பயன்படுத்துவதன் மூலம் செயல்படுத்தல் மேலும் எளிதாக்கப்படுகிறது , இது ஒருங்கிணைந்த செயல்பாட்டு அழைப்பின் திரும்பும் வகையைத் தானாகக் குறைக்கிறது. மேலும், ஒன்றிணைத்தல் உட்பட மிகவும் சிக்கலான பணிகளை நிர்வகிக்க இந்த நுட்பத்தை விரிவாக்கலாம் பிற பிழை வகைகளைக் கொண்ட மதிப்புகள் அல்லது செயல்பாட்டிற்கு அனுப்பும் முன் மதிப்புகளை மாற்றுதல். அதன் தகவமைப்புத் தன்மை காரணமாக, நேரான கணக்கீடுகள் முதல் சிக்கலான செயல்பாடுகள் வரை பரந்த அளவிலான பணிகளுக்கு இந்த வடிவத்தைப் பயன்படுத்தலாம்.

C++23 இல், பல std:: எதிர்பார்க்கப்படும் மதிப்புகளைக் கையாள ஒரு பொதுவான செயல்பாட்டைச் செயல்படுத்துவது குறியீடு வாசிப்புத்திறனை பெரிதும் மேம்படுத்துகிறது மற்றும் பிழை கையாளுதலை பெரிதும் எளிதாக்குகிறது. மாஜிக்_அப்ளை செயல்பாடு கொதிகலன் குறியீட்டைக் குறைக்கிறது மற்றும் செயலாக்கத்திற்கு முன் அனைத்து எதிர்பார்க்கப்பட்ட மதிப்புகளும் சரியாக உள்ளதா என்பதை உறுதிப்படுத்த, மாறுபட்ட டெம்ப்ளேட்களைப் பயன்படுத்தி பராமரிப்பை மேம்படுத்துகிறது. இந்த முறையானது பல்வேறு சூழ்நிலைகளுக்குப் பயன்படுத்தக்கூடிய ஒரு நெகிழ்வான தீர்வை வழங்குகிறது மற்றும் நவீன C++ நிரலாக்கமானது தோல்விகளைக் கையாள்வதற்கான தூய்மையான, மிகவும் பயனுள்ள வழியை வழங்குகிறது.