एकीकृत त्रुटि हैंडलिंग (माइक्रोकंट्रोलर के लिए C ++ विकल्प)

C ++ में माइक्रोकंट्रोलर्स के लिए सॉफ़्टवेयर विकसित करते समय, बहुत बार आप इस तथ्य का सामना कर सकते हैं कि मानक लाइब्रेरी का उपयोग करने से रैम और रोम दोनों को अवांछनीय अतिरिक्त संसाधन लागत हो सकती है। इसलिए, अक्सर std लाइब्रेरी से कक्षाएं और विधियां माइक्रोकंट्रोलर में कार्यान्वयन के लिए काफी उपयुक्त नहीं हैं। डायनामिक रूप से आवंटित मेमोरी, आरटीटीआई, अपवादों, और इसी तरह के उपयोग पर भी कुछ प्रतिबंध हैं। सामान्य तौर पर, कॉम्पैक्ट और फास्ट कोड लिखने के लिए, आप सिर्फ std लाइब्रेरी नहीं ले सकते हैं और typeid करना शुरू कर सकते हैं, typeid ऑपरेटर कह typeid , क्योंकि typeid समर्थन आवश्यक है, और यह पहले से ही एक ओवरहेड है, हालांकि बहुत बड़ा नहीं है।

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

कार्य

मान लें कि आपके पास एक CPU डायग्नोस्टिक सबसिस्टम है और इसमें अनगिनत रिटर्न कोड हैं, ये कहें:

 enum class Cpu_Error { Ok, Alu, Rom, Ram } ; 

यदि CPU डायग्नोस्टिक सबसिस्टम CPU मॉड्यूल में से किसी एक की विफलता का पता लगाता है, (उदाहरण के लिए, ALU या RAM), तो उसे संबंधित कोड वापस करना होगा।

एक और सबसिस्टम के लिए एक ही बात है, यह एक माप निदान होने दें, यह जाँच कर कि मापित मूल्य सीमा में है और यह आम तौर पर मान्य है (NAN या Infinity के बराबर नहीं):

 enum class Measure_Error { OutOfLimits, Ok, BadCode } ; 

प्रत्येक सबसिस्टम के लिए, एक GetLastError() विधि दें जो इस सबसिस्टम के एन्यूमरेटेड एरर टाइप को लौटाता है। CpuDiagnostic प्रकार CpuDiagnostic का CpuDiagnostic कोड CpuDiagnostic जाएगा, के लिए MeasureDiagnostic लिए MeasureDiagnostic कोड है।

और एक निश्चित लॉग है, जो जब कोई त्रुटि होती है, तो त्रुटि कोड को लॉग करना चाहिए।
समझने के लिए, मैं इसे बहुत ही सरल रूप में लिखूंगा:

 void Logger::Update() { Log(static_cast<uint32_t>(cpuDiagnostic.GetLastError()) ; Log(static_cast<uint32_t>(measureDiagstic.GetLastError()) ; } 

यह स्पष्ट है कि एन्यूमरेटेड प्रकारों को पूर्णांक में परिवर्तित करते समय, हम विभिन्न प्रकारों के लिए समान मान प्राप्त कर सकते हैं। यह कैसे भेद करें कि पहली त्रुटि कोड Cpu डायग्नोस्टिक सबसिस्टम का त्रुटि कोड है, और दूसरा माप सबसिस्टम?

समाधान खोजे

GetLastError() मेथड के लिए अलग-अलग सबसिस्टम के लिए अलग-अलग कोड वापस करना तर्कसंगत होगा। माथे में सबसे प्रत्यक्ष निर्णयों में से प्रत्येक के लिए कोड की विभिन्न श्रेणियों का उपयोग करना होगा। कुछ इस तरह

 constexpr tU32 CPU_ERROR_ALU = 0x10000001 ; constexpr tU32 CPU_ERROR_ROM = 0x10000002 ; ... constexpr tU32 MEAS_ERROR_OUTOF = 0x01000001 ; constexpr tU32 MEAS_ERROR_BAD = 0x01000002 ; ... enum class Cpu_Error { Ok, Alu = CPU_ERROR_ALU, Rom = CPU_ERROR_ROM, Ram = CPU_ERROR_RAM } ; ... 

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

वास्तव में, यह बहुत अच्छा होगा अगर यह संभव न हो कि तबादलों को स्पर्श न किया जाए, अपने कोड को थोड़ा अलग तरीके से विस्तारित किया जाए, उदाहरण के लिए, ऐसा करने में सक्षम होना:

 ResultCode result = Cpu_Error::Ok ; //GetLastError()   Cpu_Error result = cpuDiagnostic.GetLastError() ; if(result) //    { //       Logger::Log(result) ; } //GetLastError()   Measure_Error result = measureDiagnostic.GetLastError() ; if(result) //    { //       Logger::Log(result) ; } 

या तो:

 ReturnCode result ; for(auto it: diagnostics) { //GetLastError()     result = it.GetLastError() ; if (result) //    { Logger::Log(result) ; //      } } 

या तो:

 void CpuDiagnostic::SomeFunction(ReturnCode errocode) { Cpu_Error status = errorcode ; switch (status) { case CpuError::Alu: // do something ; break; .... } } 

जैसा कि आप कोड से देख सकते हैं, कुछ क्लास ReturnCode का उपयोग यहां किया गया है, जिसमें त्रुटि कोड और उसकी श्रेणी दोनों शामिल होने चाहिए। मानक पुस्तकालय में इस तरह के एक वर्ग std::error_code , जो वास्तव में लगभग यह सब करता है। बहुत अच्छी तरह से इसका उद्देश्य यहाँ वर्णित है:

आपका अपना std :: code_error
C ++ में सिस्टम त्रुटियों के लिए समर्थन
भविष्य के "C ++" में नियतात्मक अपवाद और त्रुटि से निपटने

मुख्य शिकायत यह है कि इस वर्ग का उपयोग करने के लिए, हमें std::error_category को इनहेरिट करने की आवश्यकता है, जो छोटे माइक्रोकंट्रोलर पर फर्मवेयर में उपयोग के लिए स्पष्ट रूप से भारी है। यहां तक ​​कि कम से कम एसटीडी :: स्ट्रिंग का उपयोग करना

 class CpuErrorCategory: public std::error_category { public: virtual const char * name() const; virtual std::string message(int ev) const; }; 

इसके अलावा, आपको मैन्युअल रूप से इसके प्रत्येक प्रगणित प्रकार के लिए श्रेणी (नाम और संदेश) का वर्णन करना होगा। और यह भी कोड std::error_code में त्रुटि की अनुपस्थिति को इंगित करता है। 0. और ऐसे संभावित मामले हैं जब प्रत्येक प्रकार के लिए त्रुटि कोड अलग होगा।
मैं श्रेणी संख्या जोड़ने के अलावा कोई उपरि नहीं रखना चाहूंगा।

इसलिए, ऐसा कुछ "आविष्कार" करना तर्कसंगत होगा जो डेवलपर को अपने प्रगणित प्रकार के लिए एक श्रेणी जोड़ने के मामले में न्यूनतम आंदोलनों को बनाने की अनुमति देगा।

सबसे पहले आपको std::error_code समान एक वर्ग बनाने की आवश्यकता है std::error_code , किसी भी एन्यूमरेटेड टाइप को पूर्णांक में बदलने में सक्षम और एक पूर्णांक से एन्यूमरेटेड टाइप के विपरीत। इन सुविधाओं के अलावा, श्रेणी को वापस करने में सक्षम होने के लिए, कोड का वास्तविक मूल्य, साथ ही जांच करने में सक्षम होना चाहिए:

 //GetLastError()   CpuError ReturnCode result(cpuDiagnostic.GetLastError()) ; if(result) //    { ... } 

निर्णय

कक्षा को अपने आप में एक त्रुटि कोड, एक श्रेणी कोड और त्रुटियों की अनुपस्थिति के अनुरूप एक कोड, एक संचालक और एक असाइनमेंट ऑपरेटर होना चाहिए। निम्न वर्ग निम्नानुसार है:




यहां क्या हो रहा है, इसे थोड़ा स्पष्ट करना आवश्यक है। एक टेम्पलेट कंस्ट्रक्टर के साथ शुरू करने के लिए

  template<class T> explicit ReturnCode(const T initReturnCode): errorValue(static_cast<tU32>(initReturnCode)), errorCategory(GetCategory(initReturnCode)), goodCode(GetOk(initReturnCode)) { static_assert(std::is_enum<T>::value, "   ") ; } 

यह आपको किसी भी प्रकार से ऑब्जेक्ट क्लास बनाने की अनुमति देता है:

 ReturnCode result(Cpu_Error::Ok) ; ReturnCode result1(My_Error::Error1); ReturnCode result2(cpuDiagnostic.GetLatestError()) ; 

यह सुनिश्चित करने के लिए कि कंस्ट्रक्टर केवल एक एन्यूमरेटेड प्रकार को स्वीकार कर सकता है, static_assert को उसके शरीर static_assert जोड़ा जाता है, जो संकलित समय पर std::is_enum का उपयोग करके कंस्ट्रक्टर को दिए गए प्रकार की जाँच करेगा और स्पष्ट पाठ के साथ std::is_enum त्रुटि std::is_enum । असली कोड यहां उत्पन्न नहीं होता है, यह सब संकलक के लिए है। तो वास्तव में यह एक खाली कंस्ट्रक्टर है।

कंस्ट्रक्टर भी निजी विशेषताओं को इनिशियलाइज़ करता है, मैं इस पर बाद में आऊँगा ...
अगला, कास्ट ऑपरेटर:

 template<class T> operator T() const { //Cast to only enum types static_assert(std::is_enum<T>::value, "   ") ; return static_cast<T>(errorValue) ; } 

यह केवल एक एन्यूमरेटेड प्रकार का नेतृत्व कर सकता है और हमें निम्नलिखित कार्य करने की अनुमति देता है:

  ReturnCode returnCode(Cpu_Error::Rom) ; Cpu_Error status = errorCode ; returnCode = My_Errror::Error2; My_Errror status1 = returnCode ; returnCode = myDiagnostic.GetLastError() ; MyDiagsonticError status2 = returnCode ; 

अच्छी तरह से और अलग से बूल () ऑपरेटर:

  operator bool() const { return (GetValue() != goodCode); } 

यह हमें सीधे जाँच करने की अनुमति देगा कि क्या रिटर्न कोड में कोई त्रुटि है:

 //GetLastError()   Cpu_Error ReturnCode result(cpuDiagnostic.GetLastError()) ; if(result) //    { ... } 

यह अनिवार्य रूप से सभी है। प्रश्न GetCategory() और GetOkCode() फ़ंक्शंस में रहता है। जैसा कि आप अनुमान लगा सकते हैं, पहले वाले को एन्यूमेरेटेड टाइप के लिए किसी भी तरह से अपनी श्रेणी को ReturnCode क्लास में ReturnCode करने के लिए ReturnCode , और दूसरे को एन्यूमेरेटेड टाइप के लिए यह इंगित करना है कि यह एक अच्छा रिटर्न कोड है, क्योंकि हम bool() ऑपरेटर के साथ इसकी तुलना करने जा रहे हैं।

यह स्पष्ट है कि ये फ़ंक्शन उपयोगकर्ता द्वारा प्रदान किए जा सकते हैं, और हम तर्क-निर्भर खोज तंत्र के माध्यम से ईमानदारी से उन्हें अपने निर्माता में कॉल कर सकते हैं।
उदाहरण के लिए:

 enum class CategoryError { Nv = 100, Cpu = 200 }; enum class Cpu_Error { Ok, Alu, Rom } ; inline tU32 GetCategory(Cpu_Error errorNum) { return static_cast<tU32>(CategoryError::Cpu); } inline tU32 GetOkCode(Cpu_Error) { return static_cast<tU32>(Cpu_Error::Ok); } 

इसके लिए डेवलपर से अतिरिक्त प्रयास की आवश्यकता होती है। हमें प्रत्येक एन्यूमरेटेड प्रकार की आवश्यकता है जिसे हम इन दो तरीकों को जोड़ने के लिए श्रेणीबद्ध करना चाहते हैं और श्रेणीवार गणना को अपडेट करना चाहते हैं।

हालांकि, हमारी इच्छा डेवलपर के लिए कोड में लगभग कुछ भी नहीं जोड़ने की है और इस बात की जहमत नहीं उठाती है कि किस तरह से अपने विस्तृत प्रकार का विस्तार किया जाए।
क्या किया जा सकता है।

• सबसे पहले, श्रेणी के लिए स्वचालित रूप से गणना करना बहुत अच्छा था, और डेवलपर को प्रत्येक गणन के लिए GetCategory() पद्धति का कार्यान्वयन प्रदान नहीं करना होगा ।
• दूसरे, हमारे कोड में 90% मामलों में, अच्छा कोड वापस करने के लिए Ok का उपयोग किया जाता है। इसलिए, आप इन 90% के लिए एक सामान्य कार्यान्वयन लिख सकते हैं, और 10% के लिए आपको विशेषज्ञता हासिल करनी होगी।

तो, चलो पहले कार्य पर ध्यान केंद्रित करें - स्वचालित श्रेणी गणना। मेरे सहकर्मी द्वारा सुझाया गया विचार यह है कि डेवलपर को अपने संलग्न प्रकार को पंजीकृत करने में सक्षम होना चाहिए। यह एक तर्कों की एक चर संख्या के साथ टेम्पलेट का उपयोग करके किया जा सकता है। ऐसी संरचना की घोषणा करें

 template <typename... Types> struct EnumTypeRegister{}; //     

अब एक नई गणना को पंजीकृत करने के लिए, जिसे एक श्रेणी द्वारा विस्तारित किया जाना चाहिए, हम बस एक नए प्रकार को परिभाषित करते हैं

 using CategoryErrorsList = EnumTypeRegister<Cpu_Error, Measure_Error>; 

यदि अचानक हमें एक और एन्यूमरेशन जोड़ने की आवश्यकता है, तो बस इसे टेम्प्लेट मापदंडों की सूची में जोड़ें:

 using CategoryErrorsList = EnumTypeRegister<Cpu_Error, Measure_Error, My_Error>; 

जाहिर है, हमारी लिस्टिंग के लिए श्रेणी टेम्पलेट पैरामीटर की सूची में एक स्थिति हो सकती है, अर्थात्। Cpu_Error यह 0 है , Measure_Error यह 1 है , My_Error यह 2 है । यह स्वचालित रूप से गणना करने के लिए संकलक को मजबूर करने के लिए रहता है। C ++ 14 के लिए, हम यह करते हैं:

 template <typename QueriedType, typename Type> constexpr tU32 GetEnumPosition(EnumTypeRegister<Type>) { static_assert(std::is_same<Type, QueriedType>::value, "     EnumTypeRegister"); return tU32(0U) ; } template <typename QueriedType, typename Type, typename... Types> constexpr std::enable_if_t<std::is_same<Type, QueriedType>::value, tU32> GetEnumPosition(EnumTypeRegister<Type, Types...>) { return 0U ; } template <typename QueriedType, typename Type, typename... Types> constexpr std::enable_if_t<!std::is_same<Type, QueriedType>::value, tU32> GetEnumPosition(EnumTypeRegister<Type, Types...>) { return 1U + GetEnumPosition<QueriedType>(EnumTypeRegister<Types...>()) ; } 

यहाँ क्या चल रहा है संक्षेप में, GetEnumPosition<T<>> फ़ंक्शन, इनपुट पैरामीटर के साथ EnumTypeRegister Enumerated प्रकारों की एक सूची है, हमारे मामले में EnumTypeRegister<Cpu_Error, Measure_Error, My_Error> , और टेम्पलेट पैरामीटर T एक एन्यूमरेटेड प्रकार है जिसका सूचकांक हमें खोजना चाहिए। सूची के माध्यम से चलता है और यदि T सूची में किसी एक प्रकार से मेल खाता है, तो इसका सूचकांक लौटाता है, अन्यथा "टाइप EnumTypeRegister सूची में पंजीकृत नहीं है" संदेश प्रदर्शित होता है

 //..    constexpr EnumTypeRegister<Cpu_Error, Measure_Error, My_Error> list //  GetEnumPosition<Measure_Error>(list) //   1 -    Measure_Error   . 

आइए अधिक विस्तार से विश्लेषण करें। सबसे कम कार्य

 template <typename QueriedType, typename Type, typename... Types> constexpr std::enable_if_t<!std::is_same<Type, QueriedType>::value, tU32> GetEnumPosition(TypeRegister<Type, Types...>) { return 1U + GetEnumPosition<QueriedType>(TypeRegister<Types...>()) ; } 

यहां शाखा std::enable_if_t< !std::is_same .. जाँचता है कि अनुरोधित प्रकार टेम्पलेट सूची में पहले प्रकार से मेल खाता है, यदि नहीं, तो GetEnumPosition फ़ंक्शन का लौटा प्रकार GetEnumPosition होगा और फिर फ़ंक्शन बॉडी निष्पादित की जाती है, अर्थात, उसी फ़ंक्शन का पुनरावर्ती कॉल फिर से। , जबकि टेम्पलेट तर्कों की संख्या 1 से कम हो जाती है, और वापसी मूल्य 1 से बढ़ जाता है। यही है, प्रत्येक पुनरावृत्ति में इस के समान कुछ होगा:

 //Iteration 1, 1+: tU32 GetEnumPosition<T>(EnumTypeRegister<Cpu_Error, Measure_Error, My_Error>) //Iteration 2, 1+1+: tU32 GetEnumPosition<T>(EnumTypeRegister<Measure_Error, My_Error>) //Iteration 3, 1+1+1: tU32 GetEnumPosition<T>(EnumTypeRegister<My_Error>) 

एक बार सूची के सभी प्रकार समाप्त हो जाने के बाद, std::enable_if_t GetEnumPosition() फ़ंक्शन के रिटर्न मान के प्रकार का अनुमान लगाने में सक्षम नहीं होगा, और इस समय पर यह पुनरावृत्ति समाप्त हो जाएगी:

 //         GetEnumPosition<T>(TypeRegister<>) template <typename QueriedType, typename Type> constexpr tU32 GetEnumPosition(EnumTypeRegister<Type>) { static_assert(std::is_same<Type, QueriedType>::value, "     EnumTypeRegister"); return tU32(0U) ; } 

सूची में टाइप होने पर क्या होता है। इस स्थिति में, एक अन्य शाखा काम करेगी, शाखा c std::enable_if_t< std::is_same .. :

 template <typename QueriedType, typename Type, typename... Types> constexpr std::enable_if_t<std::is_same<Type, QueriedType>::value, tU32> GetEnumPosition(TypeRegister<Type, Types...>) { return 0U ; } 

यहाँ प्रकार std::enable_if_t< std::is_same ... के संयोग के लिए एक जाँच है std::enable_if_t< std::is_same ... और, यदि इनपुट पर कहें तो एक प्रकार है Measure_Error , तो निम्न अनुक्रम प्राप्त होता है:

 //Iteration 1, tU32 GetEnumPosition<Measure_Error>(EnumTypeRegister<Cpu_Error, Measure_Error, My_Error>) { return 1U + GetEnumPosition<Measure_Error>(EnumTypeRegister<Measure_Error, My_Error>) } //Iteration 2: tU32 GetEnumPosition<Measure_Error>(EnumTypeRegister<Measure_Error, My_Error>) { return 0 ; } 

दूसरी पुनरावृत्ति पर, पुनरावर्ती फ़ंक्शन कॉल समाप्त होता है और हमें आउटपुट पर 1 (पहली पुनरावृत्ति) + 0 (दूसरी) से = 1 मिलता है - यह सूची EnumTypeRegister<Cpu_Error, Measure_Error, My_Error> सूची में EnumTypeRegister<Cpu_Error, Measure_Error, My_Error> का एक सूचकांक है।

चूंकि यह एक constexpr, कार्य है constexpr, सभी गणना संकलन चरण में की जाती है और कोई भी कोड वास्तव में उत्पन्न नहीं होता है।

यह सब नहीं लिखा जा सका, C ++ 17 के निपटान में। दुर्भाग्य से, मेरा IAR कंपाइलर C ++ 17 का पूरी तरह से समर्थन नहीं करता है, और इसलिए पूरे फुटक्लॉथ को निम्नलिखित कोड से बदलना संभव था:

 //for C++17 template <typename QueriedType, typename Type, typename... Types> constexpr tU32 GetEnumPosition(EnumTypeRegister<Type, Types...>) { //        if constexpr (std::is_same<Type, QueriedType>::value) { return 0U ; } else { return 1U + GetEnumPosition<QueriedType>(EnumTypeRegister<Types...>()) ; } } 

यह अभी भी हो गया है कि टेम्पलेट तरीके GetCategory() और GetOk() , जो GetEnumPosition ।

 template<typename T> constexpr tU32 GetCategory(const T) { return static_cast<tU32>(GetEnumPosition<T>(categoryDictionary)); } template<typename T> constexpr tU32 GetOk(const T) { return static_cast<tU32>(T::Ok); } 

वह सब है। आइए अब देखते हैं कि इस वस्तु के निर्माण के साथ क्या होता है:

 ReturnCode result(Measure_Error::Ok) ; 

आइए ReturnCode क्लास के कंस्ट्रक्टर के पास वापस जाएं

 template<class T> explicit ReturnCode(const T initReturnCode): errorValue(static_cast<tU32>(initReturnCode)), errorCategory(GetCategory(initReturnCode)), goodCode(GetOk(initReturnCode)) { static_assert(std::is_enum<T>::value, "The type have to be enum") ; } 

यह एक टेम्प्लेट एक है, और यदि T एक Measure_Error जिसका अर्थ है कि GetCategory(Measure_Error) विधि का GetCategory(Measure_Error) कहा जाता है, प्रकार के लिए, जो Measure_Error , जो बदले में GetEnumPosition साथ GetEnumPosition<Measure_Error>(EnumTypeRegister<Cpu_Error, Measure_Error, My_Error>) जो सूची में Measure_Error की स्थिति लौटाता है। स्थिति 1 है । और वास्तव में Measure_Error प्रकार पर पूरी रचना कोड को Measure_Error के साथ Measure_Error जाता है:

 explicit ReturnCode(const Measure_Error initReturnCode): errorValue(1), errorCategory(1), goodCode(1) { } 

परिणाम

एक डेवलपर जो ReturnCode का उपयोग ReturnCode है ReturnCode उसके लिए केवल एक चीज है:
सूची में अपने प्रगणित प्रकार को पंजीकृत करें।

 // Add enum in the category using CategoryErrorsList = EnumTypeRegister<Cpu_Error, Measure_Error, My_Error>; 

और कोई अनावश्यक आंदोलनों नहीं, मौजूदा कोड नहीं चलता है, और विस्तार के लिए आपको सूची में टाइप को पंजीकृत करने की आवश्यकता है। इसके अलावा, यह सब संकलन चरण में किया जाएगा, और संकलक न केवल सभी श्रेणियों की गणना करेगा, बल्कि आपको चेतावनी भी देगा कि क्या आप टाइप रजिस्टर करना भूल गए हैं, या एक प्रकार पास करने की कोशिश की है जो गैर-गणना योग्य नहीं है।

निष्पक्षता में, यह ध्यान देने योग्य है कि उन 10% कोड में जहां एन्यूमरेशन का ओके कोड के बजाय एक अलग नाम है, आपको इस प्रकार के लिए अपनी विशेषज्ञता बनानी होगी।

 template<> constexpr tU32 GetOk<MyError>(const MyError) { return static_cast<tU32>(MyError::Good) ; } ; 

मैंने यहां एक छोटा उदाहरण पोस्ट किया: कोड उदाहरण

सामान्य तौर पर, यहां एक आवेदन है:

 enum class Cpu_Error { Ok, Alu, Rom, Ram } ; enum class Measure_Error { OutOfLimits, Ok, BadCode } ; enum class My_Error { Error1, Error2, Error3, Error4, Ok } ; // Add enum in the category list using CategoryErrorsList = EnumTypeRegister<Cpu_Error, Measure_Error, My_Error>; Cpu_Error CpuCheck() { return Cpu_Error::Ram; } My_Error MyCheck() { return My_Error::Error4; } int main() { ReturnCode result(CpuCheck()); //cout << " Return code: "<< result.GetValue() // << " Return category: "<< result.GetCategoryValue() << endl; if (result) //if something wrong { result = MyCheck() ; // cout << " Return code: "<< result.GetValue() // << " Return category: "<< result.GetCategoryValue() << endl; } result = Measure_Error::BadCode ; //cout << " Return code: "<< result.GetValue() // << " Return category: "<< result.GetCategoryValue() << endl; result = Measure_Error::Ok ; if (!result) //if all is Ok { Measure_Error mError = result ; if (mError == Measure_Error::Ok) { // cout << "mError: "<< tU32(mError) << endl; } } return 0; } 

निम्नलिखित पंक्तियों को प्रिंट करें:

रिटर्न कोड: 3 रिटर्न श्रेणी: 0
रिटर्न कोड: 3 रिटर्न श्रेणी: 2
रिटर्न कोड: 2 रिटर्न श्रेणी: 1
mError: 1