std::apply on std:: C++23 मध्ये अपेक्षित वापरणे

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 मधील त्रुटी हाताळणे सुलभ करण्यासाठी स्क्रिप्टमध्ये type वापरला जातो. नावाचे जेनेरिक फंक्शन विकसित करणे हे मुख्य ध्येय आहे जे अनेकांचे आउटपुट प्रसारित करू शकते दुसऱ्या फंक्शनची मूल्ये. असे केल्याने, कंटाळवाणा त्रुटी-तपासणी जे सहसा अनेकांसह काम करताना आवश्यक असते std::expected मूल्ये कमी केली आहेत. खूप लवचिक आहे कारण यास कितीही लागू शकतात विविध टेम्पलेट्स वापरून पॅरामीटर्स. कोणत्याही सामग्रीसह फंक्शन कॉल करण्यापूर्वी ऑब्जेक्ट, चे मूलभूत तर्क १ पट अभिव्यक्ती वापरते, , सर्व खात्री करण्यासाठी वस्तूंची वैध मूल्ये आहेत.

ही कल्पना पहिल्या स्क्रिप्ट उदाहरणामध्ये साध्या प्रकारांचा वापर करून स्पष्ट केली आहे जसे की आणि . ते परिभाषित करते अ फंक्शन जे मूलभूत गणना करते, आणि getA आणि परत येणारी कार्ये प्रकार पासून दोन्ही मूल्ये असल्यास आणि getB कायदेशीर आहेत, आम्ही कॉल करू शकतो वापरून ; नसल्यास, त्रुटीचा प्रसार केला जातो. बॉयलरप्लेट कोड कमी करून, ही पद्धत वाचनीयता आणि देखभालक्षमता वाढवते. अशीच कल्पना दुसऱ्या स्क्रिप्टमध्ये मांडण्यात आली आहे, परंतु दृष्टिकोनाच्या अष्टपैलुत्वावर प्रकाश टाकण्यासाठी, प्रकार आणि २१ वापरले जातात.

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

१

व्हेरिएडिक टेम्प्लेट्ससह C++ एरर हँडलिंग सुधारणे

ची क्षमता क्लिष्ट प्रणालींमध्ये त्रुटी हाताळणे मोठ्या प्रमाणात वाढवणे हा C++ मध्ये वापरण्याचा आणखी एक महत्त्वाचा फायदा आहे. अनेक असिंक्रोनस क्रियांचे परिणाम अखंडपणे एकत्र करणे आवश्यक आहे अशा परिस्थितीत जेव्हा ते उत्पन्न करतात प्रकार कोड सोपा करण्याव्यतिरिक्त, ही पद्धत मजबूत त्रुटी हाताळण्याची हमी देते. ची अनियंत्रित संख्या एकत्र करून अधिक बहुमुखी आणि सामान्य कार्ये तयार केली जाऊ शकतात सह मूल्ये २५.

च्या अष्टपैलुत्व विविध प्रकारच्या युक्तिवादात घेणाऱ्या फंक्शन्ससह वापरण्याची अनुमती देते. वापर करून अंमलबजावणी आणखी सोपी केली आहे , जे आपोआप एकत्रित फंक्शन कॉलचा रिटर्न प्रकार काढते. शिवाय, विलीनीकरणासह अधिक क्लिष्ट कार्ये व्यवस्थापित करण्यासाठी या तंत्राचा विस्तार केला जाऊ शकतो इतर त्रुटी प्रकारांसह मूल्ये किंवा त्यांना फंक्शनमध्ये पाठवण्यापूर्वी मूल्यांमध्ये बदल करणे. त्याच्या अनुकूलतेमुळे, नमुना सरळ गणनेपासून जटिल ऑपरेशन्सपर्यंत विस्तृत कार्यांसाठी वापरला जाऊ शकतो.

C++23 मध्ये, एकाधिक std::अपेक्षित मूल्ये हाताळण्यासाठी जेनेरिक फंक्शन लागू केल्याने कोड वाचनीयता मोठ्या प्रमाणात सुधारते आणि त्रुटी हाताळणे मोठ्या प्रमाणात सुलभ होते. मॅजिक_अप्लाय फंक्शन बॉयलरप्लेट कोड कमी करते आणि प्रक्रिया करण्यापूर्वी सर्व अपेक्षित मूल्ये बरोबर आहेत याची खात्री करण्यासाठी विविध टेम्पलेट्स वापरून देखभालक्षमता वाढवते. ही पद्धत एक लवचिक उपाय देते जी वेगवेगळ्या परिस्थितींवर लागू केली जाऊ शकते आणि आधुनिक C++ प्रोग्रामिंगला अपयश हाताळण्याचा अधिक प्रभावी मार्ग देते.