एक और "स्ट्रिंग्स के लिए स्विच" - लेकिन न केवल स्ट्रिंग्स के लिए और न केवल "स्विच" के लिए

C ++ के लिए स्विच ऑपरेटर के बारे में और मूल्यांकन के लिए एक और विचार और कार्यान्वयन के साथ समुदाय प्रदान करने की इच्छा के बारे में habrahabr.ru/post/166201 पर एक दिलचस्प विषय द्वारा इस लेख को उकसाया गया था।

C ++ में स्विच ऑपरेटर की कमियों में से एक सीमित प्रकार का डेटा है जिस पर इसे लागू किया जा सकता है, और संदर्भ द्वारा लेख के लेखक ने एक दिलचस्प समाधान लाया।

मैं एक और समाधान का प्रस्ताव देने की कोशिश करूंगा, जो इतना अच्छा नहीं हो सकता है, लेकिन इसके लिए भाषा की अतिरिक्त सुविधाओं की आवश्यकता नहीं है और सी ++ में किसी भी प्रकार के चर के लिए काम करता है और दी गई शर्तों के लिए सभी संभावित सत्य विकल्पों को भी संसाधित करता है।

यानी एक और "स्ट्रिंग्स के लिए स्विच" - लेकिन न केवल स्ट्रिंग्स के लिए और न केवल "स्विच" के लिए।

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

विचार एक टर्नरी ऑपरेटर का उपयोग करना है ?: एक स्विच स्थिति में

मान लीजिए कि "परीक्षण" एक परीक्षण चर है और "var_ i" i = 1, .., 4 वे चर हैं जिनके साथ इसकी तुलना की जानी चाहिए

निर्माण से

bool bool_1, bool_2, bool_3, bool_4;
bool_1 = (परीक्षण == var_1);
bool_2 = (परीक्षण == var_2);
bool_3 = (परीक्षण == var_3);
bool_4 = (परीक्षण == var_4);

यह स्पष्ट है कि bool_ ii = 1, .., 4 तार्किक स्थिति हैं और चर परीक्षण और var_i i = 1, .., 4 किसी भी प्रकार के हो सकते हैं, सबसे महत्वपूर्ण बात यह है कि वे एक ही प्रकार के हैं।

अगली पंक्ति में विचार करें

स्विच (bool_1? 1: 0) | (bool_2? 2: 0) | (bool_4: 0: 0) - (bool_4? 8: 0))

और इस तथ्य में निहित है कि निर्णय लेने के लिए स्विच प्राप्त होगा, दो की बाइनरी शक्तियों पर "या" ऑपरेशन का परिणाम।

यह न केवल एक क्लासिक स्विच देता है, बल्कि सभी सत्य विकल्पों का वादा किया प्रसंस्करण भी है अर्थात्। 4 स्थितियों के लिए सभी 16 विकल्प।

प्रत्येक टर्नरी ऑपरेटर के दूसरे तर्क में दो की क्रमिक शक्तियों को ध्यान में रखते हुए स्विच में स्थितियां किसी भी मात्रा में जोड़ी जा सकती हैं

स्पष्टीकरण आगे:



सबसे पहले, टर्नरी ऑपरेटर के बारे में - वह, जैसा कि आप जानते हैं, चर बूल_ ii = 1, .., 4 की सच्चाई से दो या अगले 0 की शक्ति का चयन करेगा। दो में से चुना गया था, बेशक, संयोग से नहीं, वे सभी संभव सत्य विकल्पों को संसाधित करना संभव बनाते हैं।

अगर हमारे पास एक और केवल एक bool_ i की स्थिति है, तो स्विच क्लासिक तरीके से काम करेगा और bool_ i का चयन करेगा क्योंकि अन्य सभी 0. देंगे। स्विच का परिणाम वह स्थिति होगी जिसमें चर bool_ i सत्य है।

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

यानी स्विच उस मामले में बदल जाएगा जहां बस ये कई अलग-अलग बूल_ि चर सत्य हैं और अन्य स्थितियां झूठी हैं।

नीचे एक कार्यशील संस्करण है जिसमें केवल एक शर्त b__ की सत्यता के शास्त्रीय मामले में, परीक्षण चर परीक्षण को var_i के संबंधित मान को सौंपा गया है
सत्य वितरण के शेष संस्करणों के लिए, मैंने अंग्रेजी में सत्य के संगत विवरण दिए।

स्विच (bool_1? 1: 0) | (bool_2? 2: 0) | (bool_4: 0: 0) - (bool_4? 8: 0))
{
स्थिति 1: परीक्षण = var_1;
तोड़;
केस 2: परीक्षण = var_2;
तोड़;
स्थिति 4: परीक्षण = var_3;
तोड़;
केस 8: परीक्षण = var_4;
तोड़;
केस 3: std :: cout << "bool_1 bool_2 true bool_3 bool_4 मिथ्या" << std :: rl;
तोड़;
केस 5: std :: cout << "bool_1 bool_3 true bool_2 bool_4 गलत" << std :: ll;
तोड़;
केस 9: std :: cout << "bool_1 bool_4 true bool_2 bool_3 मिथ्या" << std :: rl;
तोड़;
केस 6: std :: cout << "bool_2 bool_3 सच bool_1 bool_4 गलत" << std :: ll;
तोड़;
केस 10: std :: cout << "bool_2 bool_4 true bool_1 bool_3 गलत" << std :: ll;
तोड़;
मामला 12: std :: cout << "bool_3 bool_4 true bool_1 bool_2 असत्य" << std :: ll;
तोड़;
केस 7: std :: cout << "bool_3 bool_2 bool_1 true bool_4 false" << std :: rl;
तोड़;
केस 11: std :: cout << "bool_4 bool_2 bool_1 true bool_3 false" << std :: rl;
तोड़;
केस 14: std :: cout << "bool_4 bool_2 bool_3 true bool_1 false" << std :: rl;
तोड़;
मामला 13: std :: cout << "bool_4 bool_1 bool_3 सच bool_2 असत्य" << std :: ll;
तोड़;
केस 15: std :: cout << "bool_4 bool_1 bool_3 bool_2 true" << std :: endl;
तोड़;

डिफ़ॉल्ट: std :: cout << "यह 0 bool_1 bool_2 bool_3 bool_4 मिथ्या जैसा है" << std :: endl;
}

दिए गए संस्करण को डेबियन के तहत जांचा गया है।

बेशक, आप एक स्क्रिप्ट लिख सकते हैं जो स्वचालित रूप से इस तरह के एक स्विच को उत्पन्न करेगा, न केवल 4 के लिए, बल्कि किसी भी स्थिति के लिए भी। चूंकि स्विच में शर्तों की संख्या की कोई सीमा नहीं है, इसलिए सीमा का उपयोग केवल मेमोरी में किया जाएगा।

सभी टिप्पणियों और सुझावों के लिए अग्रिम धन्यवाद।