C ++ 11 में स्ट्रिंग्स के लिए स्विच करें

दुर्भाग्य से, सी ++ मानक स्विच-केस स्टेटमेंट को स्ट्रिंग स्थिरांक पर लागू करने की अनुमति नहीं देता है। यद्यपि अन्य भाषाओं में, जैसे C #, यह सुविधा सीधे बॉक्स से बाहर उपलब्ध है। इसलिए, निश्चित रूप से, कई सी ++ प्रोग्रामर ने "स्ट्रिंग्स के लिए स्विच" के अपने संस्करण को लिखने की कोशिश की - और मैं कोई अपवाद नहीं हूं।
सी ++ 03 के लिए, समाधान सुंदरता में भिन्न नहीं थे और केवल कोड को जटिल करते थे, इसके अतिरिक्त रनटाइम में एप्लिकेशन को लोड करते हैं। हालांकि, C ++ 11 के आगमन के साथ, इस तरह के कोड को लागू करना संभव हो गया:

std::string month; std::string days; std::cout << "Enter month name: "; std::cin >> month; SWITCH (month) { CASE("february"): days = "28 or 29"; break; CASE("april"): CASE("june"): CASE("september"): CASE("november"): days = "30"; break; CASE("january"): CASE("march"): CASE("may"): CASE("july"): CASE("august"): CASE("october"): CASE("december"): days = "31"; break; DEFAULT: days = "?"; break; } std::cout << month << " has " << days << " days." << std::endl; 

इस डिजाइन का कार्यान्वयन बहुत सरल है। यह C ++ 11 से कॉन्स्टैक्स के कार्यों पर आधारित है, जिसके कारण लगभग सभी गणना संकलन चरण में की जाती है। अगर किसी को इसके विवरण में दिलचस्पी है, तो कैट में आपका स्वागत है - किसी कारण से "लाइनों के लिए स्विच" के बारे में हैबर पर लाभ कुछ भी नहीं कहता है।

हम क्या चाहते हैं?

सबसे पहले, कि यह एक पूर्ण-परिवर्तित स्विच था , और मैक्रोज़ के अंदर तार की तुलना करने के लिए स्टेटमेंट और फ़ंक्शंस को छिपाकर इसका "एमुलेशन" नहीं है, क्योंकि रनटाइम में स्ट्रिंग्स की तुलना करना एक महंगा ऑपरेशन है, और यह CASE की प्रत्येक पंक्ति के लिए बहुत बेकार है। इसलिए, इस तरह का एक समाधान हमारे अनुरूप नहीं होगा - इसके अलावा, END_STRING_SWITCH जैसे समझ से बाहर मैक्रोज़ अनिवार्य रूप से इसमें दिखाई देंगे।

इसके अलावा, संकलक के उपयोग को अधिकतम करने के लिए यह बहुत ही वांछनीय है। उदाहरण के लिए, "सामान्य" स्विच-केस का क्या होगा जब दो मामलों के तर्क समान हैं? यह सही है, संकलक तुरंत हमें डांटता है: "डुप्लिकेट केस वैल्यू" , और संकलन बंद कर देता है। और उपरोक्त लिंक से उदाहरण में, निश्चित रूप से, कोई संकलक इस त्रुटि को नोटिस नहीं कर सकता है।

अंतिम वाक्यविन्यास भी महत्वपूर्ण, सरल और अनावश्यक निर्माणों के बिना है। यही कारण है कि " std :: map with a string key" का प्रसिद्ध संस्करण हमें भी शोभा नहीं देता: सबसे पहले, इसमें दी गई दलीलें दृश्य नहीं लगती हैं - और दूसरी बात, इसके लिए रनटाइम में उपयोग किए गए std :: map के अनिवार्य आरंभ की आवश्यकता होती है। इस आरंभीकरण का कार्य कहीं भी हो सकता है, लगातार इसे देखना बहुत कठिन है।

हैश की गणना शुरू करें

अंतिम विकल्प शेष है: स्विच में स्ट्रिंग के हैश की गणना करें , और मामले में प्रत्येक स्ट्रिंग के हैश के साथ तुलना करें। यही है, यह सब दो पूर्णांक की तुलना करने के लिए नीचे आता है जिसके लिए स्विच-केस महान काम करता है। हालाँकि, C ++ मानक कहता है कि प्रत्येक मामले के तर्क को संकलन समय पर भी जाना जाना चाहिए - इसलिए, "स्ट्रिंग से हैश की गणना" का कार्य संकलन-समय में काम करना चाहिए। C ++ 03 में, यह केवल इस लेख में CRC गणनाओं के समान टेम्प्लेट का उपयोग करके लागू किया जा सकता है। लेकिन C ++ 11 में, सौभाग्य से, अधिक समझदार कॉन्स्ट्रेक्स फ़ंक्शन दिखाई दिए, जिनमें से मानों की गणना भी कंपाइलर द्वारा की जा सकती है।

इसलिए, हमें एक कॉन्स्ट्रेक्स फ़ंक्शन लिखना होगा जो चार वर्णों के लिए संख्यात्मक कोड के साथ काम करेगा। जैसा कि आप जानते हैं, इस तरह के एक फ़ंक्शन का शरीर " संकलन <संकलित समय में ज्ञात अभिव्यक्ति " है। चलो इसके सबसे "पतित" संस्करण को लागू करने की कोशिश करते हैं, अर्थात्, एक स्ट्रिंग के कास्ट चार * की लंबाई की गणना करने के लिए एक फ़ंक्शन। लेकिन पहले से ही यहाँ पहली कठिनाइयों का इंतजार है:

  constexpr unsigned char str_len(const char* const str) { return *str ? (1 + str_len(str + 1)) : 0; } std::cout << (int) str_len("qwerty") << " " << (int) str_len("") << std::endl; //  

संकलक कसम नहीं खाता है, फ़ंक्शन सही है। हालाँकि, किसी कारण से, वह मेरे लिए "6 6" नहीं ला पाई, लेकिन "6 12"। ऐसा क्यों? और बात यह है कि मैंने इस स्रोत कोड को "लिनक्स" में यूटीएफ -8 एन्कोडिंग के तहत विंडोज में टाइप किया था, और मानक विन -1251 में नहीं - और इसलिए प्रत्येक "सिरिलिक" चरित्र को दो के रूप में माना गया था। अब, यदि आप एन्कोडिंग को मानक में बदलते हैं, तो "6 6" वास्तव में प्रदर्शित होगा। तो यह पता चला है कि हमारे विचार दुर्घटनाग्रस्त हो गया? आखिरकार, यह मामला नहीं है जब अलग-अलग हैश अलग-अलग हैश का उत्पादन करते हैं ...

स्ट्रिंग की सामग्री की जाँच करें

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

  constexpr bool str_is_correct(const char* const str) { return (static_cast<signed char>(*str) > 0) ? str_is_correct(str + 1) : (*str ? false : true); } 

यह जाँचता है कि क्या संकलन चरण में ज्ञात स्ट्रिंग में 0-127 की सीमा तक के ही अक्षर हैं, और यदि "निषिद्ध" वर्ण पाया जाता है तो वह वापस लौट जाता है। मुझे हस्ताक्षरित चार के लिए एक मजबूर कलाकार की आवश्यकता क्यों है? तथ्य यह है कि सी ++ मानक में यह परिभाषित नहीं है कि वास्तव में चार प्रकार क्या है - यह या तो हस्ताक्षरित या अहस्ताक्षरित हो सकता है। लेकिन इसका आकार हमेशा 1 के बराबर होगा, यही वजह है कि हम एक-एक करके दाईं ओर शिफ्ट हो रहे हैं। इस प्रकार, CASE मैक्रो की हमें आवश्यकता होगी:

  #define CASE(str) static_assert(str_is_correct(str), "CASE string contains wrong characters");\ case str_hash(...) 

यहाँ C ++ 11 की एक और विशेषता का उपयोग किया गया है - संकलन पर मुखर। यही है, अगर CASE मैक्रो के तर्क स्ट्रिंग में कम से कम एक "निषिद्ध" वर्ण है, तो संकलन पूरी तरह से समझ में त्रुटि के साथ बंद हो जाएगा। अन्यथा, एक हैश की गणना की जाएगी, जिसके मूल्य को मामले में प्रतिस्थापित किया जाएगा। यह समाधान हमें एन्कोडिंग समस्याओं से बचाएगा। यह केवल str_hash () फ़ंक्शन को लिखने के लिए रहता है, जो वांछित हैश की गणना करेगा।

हैश गणना पर वापस

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

  typedef unsigned char uchar; typedef unsigned long long ullong; constexpr ullong str_hash(const char* const str, const uchar current_len) { return *str ? (raise_128_to(current_len - 1) * static_cast<uchar>(*str) + str_hash(str + 1, current_len - 1)) : 0; } 

यहां, उठ_128_to () एक शक्ति को 128 बढ़ाने का संकलन-समय का कार्य है, और current_len वर्तमान रेखा की लंबाई है। बेशक, लंबाई की गणना पुनरावृत्ति के प्रत्येक चरण में की जा सकती है, लेकिन यह केवल संकलन को धीमा कर देगा - इसे str_hash () की पहली शुरुआत से पहले गिनना बेहतर है, और फिर इसे अतिरिक्त तर्क के रूप में प्रतिस्थापित करें। इस फ़ंक्शन की अधिकतम लाइन की लंबाई में कोई टक्कर नहीं है? जाहिर है, केवल तब जब इसके द्वारा प्राप्त मूल्य हमेशा लंबे समय तक बिना किसी प्रकार के लंबे समय तक (यह भी अंत में सी ++ 11 में पेश किया जाता है) में फिट बैठता है, अर्थात यदि यह 2 ⁶⁴ -1 से अधिक नहीं है।

यह अनुमान लगाया जा सकता है कि यह अधिकतम लंबाई 9 होगी (इस संख्या को MAX_LEN के रूप में चिह्नित करें)। लेकिन अधिकतम संभव हैश मान स्ट्रिंग के लिए बिल्कुल 2 ⁶³ होगा, जिनमें से सभी वर्णों में कोड 127 (और ASCII में अपठनीय हैं , इसलिए CASE के तहत हम अभी भी इसे ड्राइव नहीं करेंगे)। लेकिन क्या होगा अगर CASE के तहत 10 वर्णों का एक स्ट्रिंग खड़ा हो? यदि हम वास्तव में टकराव नहीं चाहते हैं, तो हमें इस संभावना पर रोक लगाने की आवश्यकता है - अर्थात, static_assert का विस्तार करने के लिए जिसका हम पहले से ही उपयोग करते हैं:

  #define CASE(str) static_assert(str_is_correct(str) && (str_len(str) <= MAX_LEN),\ "CASE string contains wrong characters, or its length is greater than 9");\ case str_hash(str, str_len(str)) 

हम परिष्करण स्पर्श करते हैं

सभी मामले मैक्रो के साथ किए गए। यह या तो हमें एक संकलन त्रुटि देगा या एक अद्वितीय हैश मान की गणना करेगा। यहां, SWITCH मैक्रो में हैश की गणना करने के लिए, हमें एक अलग फ़ंक्शन करना होगा, क्योंकि यह पहले से ही रनटाइम में काम करेगा। और यदि इसके तर्क स्ट्रिंग में 9 से अधिक वर्णों की लंबाई होगी, तो हम 2 ⁶⁴ -1 को वापस करने के लिए सहमत हैं (हम इस संख्या को N_HASH के रूप में दर्शाते हैं)। तो:

  #define SWITCH(str) switch(str_hash_for_switch(str)) const ullong N_HASH = static_cast<ullong>(-1); //    std::string::npos inline ullong str_hash_for_switch(const char* const str) { return (str_is_correct(str) && (str_len(str) <= MAX_LEN)) ? str_hash(str, str_len(str)) : N_HASH; } 

बस इतना ही। रनटाइम में, SWITCH में स्ट्रिंग के लिए हैश की गणना की जाएगी, और यदि CASE में एक स्ट्रिंग में एक ही हैश है, तो निष्पादन उस पर जाएगा। यदि CASE की कुछ पंक्ति में "निषिद्ध" वर्ण हैं, या इसकी लंबाई 9 वर्णों से अधिक है, तो हमें एक विश्वसनीय संकलन त्रुटि मिलेगी। रनटाइम में लगभग कोई लोड नहीं है (SWITCH के लिए एक एकल हैश गणना के अपवाद के साथ), कोड की पठनीयता को नुकसान नहीं होता है। यह केवल st_hash_for_switch () std :: string स्ट्रिंग्स के लिए कार्य करने और नाम स्थान के अंदर सब कुछ लपेटने के लिए ही रहता है।

अंतिम स्रोत एच-फ़ाइल गितुब पर है । यह C ++ 11 समर्थन के साथ किसी भी संकलक के लिए उपयुक्त है। "स्ट्रिंग्स के लिए स्विच" का उपयोग करने के लिए, जहाँ भी आप चाहते हैं, str_switch.h को शामिल करें और यह - SWITCH, CASE और DEFAULT मैक्रोज़ आपके सामने हैं। CASE (9 वर्ण) में स्ट्रिंग की लंबाई सीमा के बारे में मत भूलना।
सामान्य तौर पर - मुझे उम्मीद है कि यह कार्यान्वयन किसी के लिए उपयोगी है;)

पुनश्च अद्यतन: कोड में कुछ गलतियाँ पाई गईं - इसलिए अब यह लेख के साथ अद्यतन किया गया है। टिप्पणियों ने हैश की गणना करने के लिए एक और फ़ंक्शन का उपयोग करने का सुझाव दिया - बेशक, हर कोई अपना कार्यान्वयन लिख सकता है।