💯 📻 🌹 C ++ में दो मापदंडों के लिए स्विच करें ✋ 🤰🏽 🤸

Habr पर पोस्ट पढ़ना, इस तरह के एक सवाल पर ठोकर खाई। टिप्पणियों में समाधान सुझाए गए थे, लेकिन फ़ंक्शन कॉल के ओवरहेड को देखते हुए लेखक के अनुकूल कोई नहीं था। और फिर मैंने सोचा, लेकिन वास्तव में क्यों नहीं एक नियमित स्विच का उपयोग करें , दो मापदंडों से एक हैश की गणना करें, जिसे स्विच में उपयोग किया जाना चाहिए। लेकिन प्रश्न के लेखक के उदाहरण को अधिक ध्यान से देखने पर, मुझे एहसास हुआ कि ऐसा विकल्प केवल उसी तरह काम नहीं करेगा, क्योंकि यह नेस्टेड स्विच के डिफ़ॉल्ट को पकड़ने के लिए आवश्यक था।

मान लें कि दो चर n और m हैं , प्रत्येक का मान 0 से 9 तक हो सकता है, और हमारे पास ऐसी संरचना है:

switch (n) { case 0: { switch (m) { case 2: case 4: ... break; case 5: ... break; default: ... break; } } break; ... }

चूँकि प्रत्येक चर का मूल्य बाइट्स में रखा गया है, हैश फ़ंक्शन को निम्नलिखित ((n << SHIFT ) + m) होने दें (जहाँ SHIFT = 8)।
और यहां समस्या उत्पन्न होती है: यदि दोनों मानों को परिभाषित किया जाता है, तो हम हैश की गणना के बाद एक विशिष्ट संख्या प्राप्त करेंगे। लेकिन अगर हम n = 0 कहें, और m 2,4,5 के बराबर नहीं है, तो इस मामले में क्या करना है? डिफ़ॉल्ट क्रिया करने के लिए शेष विकल्पों को सूचीबद्ध करना बहुत महंगा है, क्योंकि उनके मूल्यों की सीमा 0..9 से अधिक हो सकती है। यही है, वास्तव में, आपको एक निश्चित सीमा में गणना की गई हैश के मूल्य को पकड़ने की आवश्यकता है।

और फिर मैंने सोचा, क्या होगा अगर हम अपने आप को डिफॉल्ट करते हैं। यही है, पहले सभी जोड़े एम और एन के लिए मामला लिखें, जिसके लिए आपको कुछ क्रियाएं करने की आवश्यकता है, और फिर डिफ़ॉल्ट रूप से एक पैरामीटर एन के साथ नेस्टेड स्विच की घोषणा करें, ताकि सभी अन्य संयोजनों को संसाधित करने की आवश्यकता हो।

तो मुझे क्या मिला

इस तरह के एक साधारण हैश फ़ंक्शन को एक नियमित मैक्रो के साथ लागू किया जा सकता है, लेकिन चूंकि const ++ फ़ंक्शन C ++ 11 में दिखाई दिए, इसलिए मैंने उनका उपयोग करने का निर्णय लिया:

 constexpr int hash(int n, int m) { return verifyValues(n, m) ? ((n << SHIFT) + m): -1; }

, verifyValues यह सत्यापित करने के लिए एक फ़ंक्शन है कि पैरामीटर दिए गए रेंज में हैं। इसके लिए, स्थिरांक MAX_N, MAX_M का उपयोग किया जाता है, और यदि पैरामीटर मान्य नहीं हैं, तो -1 वापस आ जाएगा।

 #define isInBound(min, value, max) ((value >= min) && (value <= max)) constexpr bool verifyValues(int n, int m) { return isInBound(0, n, MAX_N) && isInBound(0, m, MAX_M); }

हैश फ़ंक्शन को देखते हुए निम्नलिखित चेक जोड़ना अच्छा होगा:

 MAX_M < pow(2, SHIFT)

मैक्रोज़ का उपयोग करके अतिरिक्त कोड और चेक छिपाएँ:

 #define SWITCH(n, m) static_assert(MAX_M < pow(2, SHIFT), "shift value is not enough to cover all M values"); \ switch(hash(n, m)) #define CASE(n, m) static_assert(verifyValues(n, m), "N or M value is out of range"); \ case hash(n, m)

यहां, स्विच का निर्धारण करते समय , हमारे हैश फ़ंक्शन की संचालन क्षमता की तुरंत जाँच की जाएगी, और बाद में प्रत्येक मामले के लिए , यह जाँच की जाएगी कि इसके चर निर्दिष्ट सीमा में हैं।

तो पहले भाग के साथ, अब डिफ़ॉल्ट खंड ही।
यहां केवल एक नेस्टेड स्विच को पंजीकृत करना संभव होगा, लेकिन जब से मैंने मैक्रोज़ लिखना शुरू किया, मैं उसके लिए इसे परिभाषित करूंगा:

 #define DEFAULT(n) \ case -1: ASSERT(false); break; \ default: switch(n) { #define DEFAULT_CASE(n) case n #define END_DEFAULT }

चूंकि हैश की गणना करते समय, फ़ंक्शन -1 वापस आ सकता है (यदि मापदंडों को गलत तरीके से पारित किया गया था), केस -1 के लिए एक हैंडलर जोड़ा गया था (मेरे उदाहरण में, यह सामान्य ASSERT है)।

नतीजतन, मुझे दो मापदंडों के साथ ऐसा स्विच मिला:

 SWITCH(a, b) { CASE(0, 1): CASE(0, 2): CASE(0, 3): CASE(0, 4): ... break; CASE(5, 3): ... break; DEFAULT(a) DEFAULT_CASE(0): ... break; DEFAULT_CASE(1): ... break; DEFAULT_CASE(2): ... break; DEFAULT_CASE(3): ... break; DEFAULT_CASE(4): ... break; DEFAULT_CASE(5): ... break; DEFAULT_CASE(6): ... break; DEFAULT_CASE(7): ... break; DEFAULT_CASE(8): ... break; DEFAULT_CASE(9): ... break; END_DEFAULT }

यहां मुख्य बात यह नहीं भूलना है कि DEFAULT मैक्रो के बाद आपको एक कोलोन डालने की आवश्यकता नहीं है।

पूरा कोड

 const int MAX_N = 10; const int MAX_M = 10; const int SHIFT = 8; #define isInBound(min, value, max) ((value >= min) && (value <= max)) constexpr bool verifyValues(int n, int m) { return isInBound(0, n, MAX_N) && isInBound(0, m, MAX_M); } constexpr int hash(int n, int m) { return verifyValues(n, m) ? ((n << SHIFT) + m): -1; } #define SWITCH(n, m) static_assert(MAX_M < pow(2, SHIFT), "shift value is not enough to cover all M values"); \ switch(hash(n, m)) #define CASE(n, m) static_assert(verifyValues(n, m), "N or M value is out of range"); \ case hash(n, m) #define DEFAULT(n) \ case -1: Q_ASSERT(false); break; \ default: switch(n) { #define DEFAULT_CASE(n) case n #define END_DEFAULT } ... SWITCH(a, b) { CASE(0, 1): CASE(0, 2): CASE(0, 3): CASE(0, 4): printf("0, 1-4\n"); break; CASE(5, 3): printf("5, 3\n"); break; DEFAULT(a) DEFAULT_CASE(0): printf("0\n"); break; DEFAULT_CASE(1): printf("1\n"); break; DEFAULT_CASE(2): printf("2\n"); break; DEFAULT_CASE(3): printf("3\n"); break; DEFAULT_CASE(4): printf("4\n"); break; DEFAULT_CASE(5): printf("5\n"); break; DEFAULT_CASE(6): printf("6\n"); break; DEFAULT_CASE(7): printf("7\n"); break; DEFAULT_CASE(8): printf("8\n"); break; DEFAULT_CASE(9): printf("9\n"); break; END_DEFAULT }

नतीजतन, हमारे पास एक स्विच है जो दो मापदंडों के साथ काम करता है। ओवरहेड की, एक प्राथमिक हैश फ़ंक्शन। लेकिन एक ही समय में, मामले के लिए, जिसके लिए दोनों मापदंडों को परिभाषित किया गया है, संक्रमण पहले स्विच में पहले से ही किया जाएगा, और डिफ़ॉल्ट रूप से, दूसरे में पहले की तरह।

मुझे उम्मीद है कि यह कार्यान्वयन किसी के लिए उपयोगी है। आपका ध्यान देने के लिए धन्यवाद।

PS सिद्धांत रूप में, ऐसी संरचना का उपयोग करके, आप न केवल दो मापदंडों के लिए स्विच लिख सकते हैं, बल्कि तीन या अधिक के लिए भी।

C ++ में दो मापदंडों के लिए स्विच करें

तो मुझे क्या मिला

More articles: