🦇 💴 😀 C ++ 2a में त्रुटि से निपटने के लिए क्या होगा 🤟🏾 🧑🏻‍🤝‍🧑🏻 🏇

कुछ हफ़्ते पहले C ++ दुनिया में मुख्य सम्मेलन था - CPPCON ।
लगातार सुबह 8 बजे से रात 10 बजे तक खबरें आईं। सभी धर्मों के प्रोग्रामरों ने सी ++ के भविष्य पर चर्चा की, बाइक को जहर दिया और सोचा कि कैसे सी ++ को आसान बनाया जाए।

आश्चर्यजनक रूप से कई रिपोर्टें त्रुटि से निपटने के लिए समर्पित थीं। अच्छी तरह से स्थापित दृष्टिकोण आपको अधिकतम प्रदर्शन प्राप्त करने की अनुमति नहीं देते हैं या कोड शीट उत्पन्न कर सकते हैं।
C ++ 2a में कौन से नवाचारों की प्रतीक्षा है?

सिद्धांत की बिट

परंपरागत रूप से, कार्यक्रम की सभी गलत स्थितियों को 2 बड़े समूहों में विभाजित किया जा सकता है:

घातक त्रुटियाँ।
घातक या अपेक्षित त्रुटियाँ नहीं।

घातक त्रुटियाँ

उनके बाद, निष्पादन को जारी रखने का कोई मतलब नहीं है।
उदाहरण के लिए, यह एक अशक्त सूचक है, जो स्मृति से गुजर रहा है, 0 से विभाजित हो रहा है, या कोड में अन्य आक्रमणकारियों का उल्लंघन कर रहा है। जब वे होते हैं तो सभी को समस्या के बारे में अधिकतम जानकारी प्रदान करने और कार्यक्रम को पूरा करने की आवश्यकता होती है।

सी ++ में ~~बहुत ज्यादा~~ कार्यक्रम को पूरा करने के लिए पहले से ही पर्याप्त तरीके हैं:

लाइब्रेरीज़ क्रैश ( 1 , 2 , 3 ) पर डेटा एकत्र करने के लिए दिखाई देने लगी हैं।

गैर घातक त्रुटियां

ये त्रुटियाँ हैं जो प्रोग्राम लॉजिक द्वारा प्रदान की जाती हैं। उदाहरण के लिए, नेटवर्क के साथ काम करते समय त्रुटियां, एक अमान्य स्ट्रिंग को एक संख्या में परिवर्तित करना, आदि। कार्यक्रम में ऐसी त्रुटियों की उपस्थिति चीजों के क्रम में है। उनके प्रसंस्करण के लिए, C ++ में कई आम तौर पर स्वीकृत रणनीति हैं।
हम एक सरल उदाहरण का उपयोग करके उनके बारे में अधिक विस्तार से बात करेंगे:

आइए, त्रुटि से निपटने के लिए अलग-अलग दृष्टिकोणों का उपयोग करके एक फ़ंक्शन void addTwo() लिखने का प्रयास करें।
फ़ंक्शन को 2 पंक्तियों को पढ़ना चाहिए, उन्हें int बदलना और योग प्रिंट करना चाहिए। IO त्रुटियों, अतिप्रवाह और संख्या में रूपांतरण को संभालने की आवश्यकता है। मैं निर्बाध कार्यान्वयन विवरणों को छोड़ दूंगा। हम 3 मुख्य दृष्टिकोणों पर विचार करेंगे।

1. अपवाद

 //     //   IO  std::runtime_error std::string readLine(); //    int //     std::invalid_argument int parseInt(const std::string& str); //  a  b //     std::overflow_error int safeAdd(int a, int b); void addTwo() { try { std::string aStr = readLine(); std::string bStr = readLine(); int a = parseInt(aStr); int b = parseInt(bStr); std::cout << safeAdd(a, b) << std::endl; } catch(const std::exeption& e) { std::cout << e.what() << std::endl; } }

C ++ में अपवाद आपको अनावश्यक बिना केंद्रीय रूप से त्रुटियों को संभालने की अनुमति देते हैं,
लेकिन आपको समस्याओं के पूरे ढेर के साथ इसके लिए भुगतान करना होगा।

अपवादों को संभालने में शामिल ओवरहेड काफी बड़ा है, आप अक्सर अपवादों को नहीं फेंक सकते।
यह बेहतर नहीं है कि निर्माणकर्ताओं / विध्वंसकों के अपवादों को न फेंके और RAII का निरीक्षण करें।
फ़ंक्शन के हस्ताक्षर से, यह समझना असंभव है कि फ़ंक्शन से अपवाद क्या उड़ सकता है।
अतिरिक्त अपवाद समर्थन कोड के कारण बाइनरी फ़ाइल का आकार बढ़ता है।

2. कोड लौटाएं

सी से विरासत में मिला शास्त्रीय दृष्टिकोण।

 bool readLine(std::string& str); bool parseInt(const std::string& str, int& result); bool safeAdd(int a, int b, int& result); void processError(); void addTwo() { std::string aStr; int ok = readLine(aStr); if (!ok) { processError(); return; } std::string bStr; ok = readLine(bStr); if (!ok) { processError(); return; } int a = 0; ok = parseInt(aStr, a); if (!ok) { processError(); return; } int b = 0; ok = parseInt(bStr, b); if (!ok) { processError(); return; } int result = 0; ok = safeAdd(a, b, result); if (!ok) { processError(); return; } std::cout << result << std::endl; }

बहुत अच्छा नहीं लगता है?

आप किसी फ़ंक्शन का वास्तविक मान नहीं लौटा सकते।
त्रुटि को हैंडल करना भूल जाना बहुत आसान है (पिछली बार जब आपने प्रिंटफ़ से रिटर्न कोड की जाँच की थी?)।
आपको प्रत्येक फ़ंक्शन के आगे एरर हैंडलिंग कोड लिखना होगा। ऐसे कोड को पढ़ना मुश्किल है।
C ++ 17 और C ++ 2a का उपयोग इन सभी समस्याओं को क्रम से ठीक करेगा।

3. सी ++ 17 और नोडोकार्ड

C ++ 17 में nodiscard है।
यदि आप इसे फ़ंक्शन घोषणा से पहले निर्दिष्ट करते हैं, तो रिटर्न मूल्य की जांच नहीं होने से संकलक चेतावनी का कारण होगा।

 [[nodiscard]] bool doStuff(); /* ... */ doStuff(); //  ! bool ok = doStuff(); // .

आप एक वर्ग, संरचना, या nodiscard वर्ग के लिए nodiscard भी निर्दिष्ट कर सकते हैं।
इस मामले में, विशेषता कार्रवाई उन सभी कार्यों तक फैली हुई है जो लेबल किए गए nodiscard मान nodiscard ।

 enum class [[nodiscard]] ErrorCode { Exists, PermissionDenied }; ErrorCode createDir(); /* ... */ createDir();

मैं nodiscard के साथ कोड प्रदान नहीं nodiscard ।

सी ++ 17 एसटी :: वैकल्पिक

C ++ 17 में, std::optional<T> ।
देखते हैं कि अब कोड कैसा दिखता है।

 std::optional<std::string> readLine(); std::optional<int> parseInt(const std::string& str); std::optional<int> safeAdd(int a, int b); void addTwo() { std::optional<std::string> aStr = readLine(); std::optional<std::string> bStr = readLine(); if (aStr == std::nullopt || bStr == std::nullopt){ std::cerr << "Some input error" << std::endl; return; } std::optional<int> a = parseInt(*aStr); std::optional<int> b = parseInt(*bStr); if (!a || !b) { std::cerr << "Some parse error" << std::endl; return; } std::optional<int> result = safeAdd(*a, *b); if (!result) { std::cerr << "Integer overflow" << std::endl; return; } std::cout << *result << std::endl; }

आप फ़ंक्शन से इन-आउट तर्क निकाल सकते हैं और कोड क्लीनर बन जाएगा।
हालाँकि, हम त्रुटि जानकारी खो रहे हैं। यह अस्पष्ट हो गया कि कब और क्या गलत हुआ।
आप std::optional को बदल सकते हैं std::optional साथ std::optional std::variant<ResultType, ValueType> ।
कोड का अर्थ std::optional साथ ही है std::optional , लेकिन अधिक बोझिल।

C ++ 2a और std :: अपेक्षित

std::expected<ResultType, ErrorType> - एक विशेष टेम्पलेट प्रकार , यह संभवतः निकटतम अपूर्ण मानक में आ जाएगा।
इसके 2 पैरामीटर हैं।

ReusltType अपेक्षित मान है।
ErrorType - त्रुटि का प्रकार।
std::expected में अपेक्षित मान या त्रुटि हो सकती है। इस प्रकार के साथ काम करना कुछ इस तरह होगा:
```
 std::expected<int, string> ok = 0; expected<int, string> notOk = std::make_unexpected("something wrong"); 
```

यह सामान्य variant से कैसे भिन्न होता है? क्या खास है इसे?
std::expected एक सन्यासी होगा ।
यह std::expected पर परिचालन का एक गुच्छा का समर्थन करने के लिए प्रस्तावित है std::expected एक catch_error पर के रूप में की std::expected : map , catch_error , bind , unwrap , return और then ।
इन फ़ंक्शन का उपयोग करके, आप चेन फ़ंक्शन को एक चेन में कॉल कर सकते हैं।

 getInt().map([](int i)return i * 2;) .map(integer_divide_by_2) .catch_error([](auto e) return 0; );

मान लें कि हमारे पास लौटने वाले std::expected साथ कार्य हैं।

 std::expected<std::string, std::runtime_error> readLine(); std::expected<int, std::runtime_error> parseInt(const std::string& str); std::expected<int, std::runtime_error> safeAdd(int a, int b);

नीचे केवल छद्म कोड है, इसे किसी भी आधुनिक संकलक में काम करने के लिए मजबूर नहीं किया जा सकता है।
आप साधुओं पर रिकॉर्डिंग कार्यों के लिए हस्केल डो-सिंटैक्स से उधार लेने का प्रयास कर सकते हैं। ऐसा करने की अनुमति क्यों न दें:

 std::expected<int, std::runtime_error> result = do { auto aStr <- readLine(); auto bStr <- readLine(); auto a <- parseInt(aStr); auto b <- parseInt(bStr); return safeAdd(a, b) }

कुछ लेखक इस वाक्य रचना का सुझाव देते हैं:

 try { auto aStr = try readLine(); auto bStr = try readLine(); auto a = try parseInt(aStr); auto b = try parseInt(bStr); std::cout result << std::endl; return safeAdd(a, b) } catch (const std::runtime_error& err) { std::cerr << err.what() << std::endl; return 0; }

संकलक स्वचालित रूप से फ़ंक्शन कॉल के अनुक्रम में कोड के ऐसे ब्लॉक को परिवर्तित करता है। अगर कुछ बिंदु पर फ़ंक्शन वापस नहीं आता है तो इसकी उम्मीद की जाती है, गणना श्रृंखला टूट जाएगी। हां, और एक त्रुटि प्रकार के रूप में, आप मानक में पहले से मौजूद अपवाद प्रकारों का उपयोग कर सकते हैं: std::runtime_error , std::out_of_range , आदि।

यदि आप वाक्य रचना को अच्छी तरह से डिजाइन कर सकते हैं, तो std::expected आपको सरल और कुशल कोड लिखने की अनुमति देगा।

निष्कर्ष

त्रुटियों को संभालने का कोई आदर्श तरीका नहीं है। कुछ समय पहले, C ++ में मोनडेस को छोड़कर त्रुटि से निपटने के लगभग सभी संभव तरीके थे।
C ++ 2a में, सभी संभावित तरीकों के प्रकट होने की संभावना है।

C ++ 2a में त्रुटि से निपटने के लिए क्या होगा