👩🏼‍🤝‍👩🏻 🛀🏽 👨🏾‍🏭 आधुनिक सी ++ में संकलन चरण में तार के साथ काम करना 📽️ 🤦 👩🏽‍💼

यदि आप C ++ में प्रोग्राम करते हैं, तो आप शायद सोचें कि आप दो स्ट्रिंग शाब्दिकों की तुलना क्यों नहीं कर सकते हैं या उनका संयोजन नहीं कर सकते हैं:

auto str = "hello" + "world"; //   if ("hello" < "world") { // ,    ,   // ... }

हालांकि, जैसा कि वे कहते हैं, "यह असंभव है, लेकिन अगर आप वास्तव में चाहते हैं, तो आप कर सकते हैं।" हम कट के नीचे रूढ़ियों को तोड़ेंगे, और संकलन के स्तर पर सही होंगे।

यह सब क्यों जरूरी है

जिन परियोजनाओं पर मैं काम कर रहा था, उनमें से एक में स्ट्रिंग कांस्टेंट के रूप में std :: string का उपयोग करने की प्रथा थी। परियोजना में कई मॉड्यूल थे जिनमें वैश्विक स्ट्रिंग स्थिरांक परिभाषित किए गए थे:

 // plugin.h const std::string PLUGIN_PATH = "/usr/local/lib/project/plugins/"; // ...

 // sample_plugin.h const std::string SAMPLE_PLUGIN_LIB = PLUGIN_PATH + "sample.so"; // ...

मुझे लगता है कि आपने पहले ही अनुमान लगा लिया था कि एक दिन क्या हुआ। SAMPLE_PLUGIN_PATH ने "sample.so" का मूल्य लिया, इस तथ्य के बावजूद कि PLUGIN_PATH का मूल्य "/usr/local/lib/project/plugins/" PLUGIN_PATH "/usr/local/lib/project/plugins/" , अपेक्षा के अनुसार। यह कैसे हो सकता है? सब कुछ बहुत सरल है, वैश्विक वस्तुओं के प्रारंभ के क्रम को परिभाषित नहीं किया गया है, प्रारंभ के समय SAMPLE_PLUGIN_PATH चर PLUGIN_PATH खाली था।

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

यह तब था जब मुझे संकलन मंच पर स्ट्रिंग्स के साथ काम करने का विचार था, जिसके कारण आखिरकार इस लेख को लिखना पड़ा।

इस लेख में, हम उन पंक्तियों पर विचार करेंगे जो संकलन चरण पर संचालित की जा सकती हैं। हम ऐसी लाइनों को स्थिर कहेंगे।

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

लाइब्रेरी का उपयोग करने के लिए कम से कम C ++ 14 आवश्यक है।

स्टेटिक स्ट्रिंग परिभाषा;

हम एक स्थिर स्ट्रिंग को वर्णों की एक सरणी के रूप में परिभाषित करते हैं, सुविधा के लिए हम मानते हैं कि स्ट्रिंग हमेशा एक अशक्त चरित्र के साथ समाप्त होती है:

 template<size_t Size> using static_string = std::array<const char, Size>; constexpr static_string<6> hello = {'H', 'e', 'l', 'l', 'o', '\0'};

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

एक स्थिर स्ट्रिंग बनाना

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

 constexpr auto hello = make_static_string("hello");

यहाँ चर टेम्पलेट के रूपों में से एक हमारी मदद करेगा, जो हमें एक स्ट्रिंग शाब्दिक से हमारे स्थिर स्ट्रिंग के कुल आरंभ के लिए संकेत के रूप में टेम्पलेट तर्कों का विस्तार करने की अनुमति देता है:

 template<size_t Size, size_t ... Indexes> constexpr static_string<sizeof ... (Indexes) + 1> make_static_string(const char (& str)[Size]) { return {str[Indexes] ..., '\0'}; } constexpr auto hello = make_static_string<0, 1, 2, 3, 4>("hello"); // hello == "hello"

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

 constexpr hello1 = make_static_string<1, 2, 3>("hello"); // hello1 == "ell" constexpr hello2 = make_static_string<4, 3, 2, 1, 0>("hello"); // hello2 == "olleh"

यह विचार भविष्य में हमारे लिए बहुत उपयोगी होगा।

अब हमें किसी तरह से पंक्ति सूचकांकों का क्रम उत्पन्न करने की आवश्यकता है। ऐसा करने के लिए, वंशानुक्रम चाल लागू करें। टेम्पलेट पैरामीटर के रूप में आवश्यक सूचकांकों के सेट के साथ एक खाली संरचना (आपको कुछ विरासत में प्राप्त करने की आवश्यकता है) को परिभाषित करें:

 template<size_t ... Indexes> struct index_sequence {};

हम एक जनरेटर संरचना को परिभाषित करते हैं जो पहले पैरामीटर में काउंटर को संचयित करते हुए एक बार में एक इंडेक्स उत्पन्न करेगा:

 template<size_t Size, size_t ... Indexes> struct make_index_sequence : make_index_sequence<Size - 1, Size - 1, Indexes ...> {};

हम पुनरावृत्ति समापन बिंदु का भी ध्यान रखेंगे, जब सभी सूचकांक उत्पन्न होते हैं (काउंटर शून्य है), हम काउंटर को छोड़ देते हैं और जनरेटर उस अनुक्रम में बदल जाता है जिसकी हमें ज़रूरत है:

 template<size_t ... Indexes> struct make_index_sequence<0, Indexes ...> : index_sequence<Indexes ...> {};

नतीजतन, एक स्थिर स्ट्रिंग बनाने का कार्य इस तरह दिखाई देगा:

 template<size_t Size, size_t ... Indexes> constexpr static_string<sizeof ... (Indexes) + 1> make_static_string(const char (& str)[Size], index_sequence<Indexes ...>) { return {str[Indexes] ..., '\0'}; }

हम एक स्थिर स्ट्रिंग के लिए एक समान फ़ंक्शन लिखेंगे, यह हमारे लिए उपयोगी होगा:

 template<size_t Size, size_t ... Indexes> constexpr static_string<sizeof ... (Indexes) + 1> make_static_string(const static_string<Size>& str, index_sequence<Indexes ...>) { return {str[Indexes] ..., '\0'}; }

इसके अलावा, प्रत्येक फ़ंक्शन के लिए जो स्ट्रिंग शाब्दिक foo(const char (& str)[Size]) लेता है, हम एक समान फ़ंक्शन लिखेंगे जो स्टेटिक स्ट्रिंग foo(const static_string<Size>& str) लेता है। लेकिन संक्षिप्तता के लिए, मैं इसका उल्लेख नहीं करूंगा।

चूंकि स्ट्रिंग शाब्दिक की लंबाई हमारे लिए जानी जाती है, हम स्वचालित रूप से सूचकांक का एक क्रम उत्पन्न कर सकते हैं, हम ऊपर दिए गए फ़ंक्शन के लिए एक आवरण लिखेंगे:

 template<size_t Size> constexpr static_string<Size> make_static_string(const char (& str)[Size]) { return make_static_string(str, make_index_sequence<Size - 1>{}); }

यह फ़ंक्शन हमें ठीक वही करने की अनुमति देता है जो हम अध्याय की शुरुआत में चाहते थे।

यदि कोई तर्क नहीं है, तो हम एक खाली स्टेटिक स्ट्रिंग लौटाएंगे, जिसमें केवल एक अशक्त वर्ण होता है:

 constexpr static_string<1> make_static_string() { return {'\0'}; }

हमें वर्णों के एक समूह से एक स्ट्रिंग बनाने की भी आवश्यकता है:

 template<char ... Chars> constexpr static_string<sizeof ... (Chars) + 1> make_static_string(char_sequence<Chars ...>) { return {Chars ..., '\0'}; }

वैसे, इस लेख में बाद में वर्णित सब कुछ इस अध्याय में वर्णित तकनीकों पर आधारित है। इसलिए, अगर कुछ समझ में नहीं आता है, तो अध्याय को फिर से पढ़ना बेहतर है।

एक धारा के लिए एक स्थिर स्ट्रिंग आउटपुट

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

 template<size_t Size> std::ostream& operator<<(std::ostream& os, const static_string<Size>& str) { os << str.data(); return os; }

स्थिर स्ट्रिंग को std :: string में बदलें

यहां कुछ भी जटिल नहीं है। हम सरणी डेटा के साथ स्ट्रिंग को इनिशियलाइज़ करते हैं:

 template<size_t Size> std::string to_string(const static_string<Size>& str) { return std::string(str.data()); }

स्टेटिक स्ट्रिंग तुलना

हम वर्णों की तुलना वर्ण रेखाओं से तब तक करेंगे जब तक कि हम अंतर नहीं खोज लेते, या जब तक हम कम से कम एक पंक्ति के अंत तक नहीं पहुँच जाते। चूंकि अभी तक कब्ज का आविष्कार नहीं हुआ है, इसलिए हम पुनरावृत्ति और टर्नरी ऑपरेटर का उपयोग करते हैं:

 template<size_t Size1, size_t Size2> constexpr int static_string_compare( const static_string<Size1>& str1, const static_string<Size2>& str2, int index = 0) { return index >= Size1 && index >= Size2 ? 0 : index >= Size1 ? -1 : index >= Size2 ? 1 : str1[index] > str2[index] ? 1 : str1[index] < str2[index] ? -1 : static_string_compare(str1, str2, index + 1); }

भविष्य में, हमें तुलनित्र के एक विस्तारित संस्करण की आवश्यकता होगी, हम उनकी प्रत्येक पंक्ति के लिए एक व्यक्तिगत सूचकांक पेश करेंगे, और हम तुलना किए गए वर्णों की संख्या को भी सीमित करेंगे:

 template<size_t Size1, size_t Size2> constexpr int static_string_compare( const static_string<Size1>& str1, size_t index1, const static_string<Size2>& str2, size_t index2, size_t cur_length, size_t max_length) { return cur_length > max_length || (index1 >= Size1 && index2 >= Size2) ? 0 : index1 >= Size1 ? -1 : index2 >= Size2 ? 1 : str1[index1] > str2[index2] ? 1 : str1[index1] < str2[index2] ? -1 : static_string_compare(str1, index1 + 1, str2, index2 + 1, cur_length + 1, max_length); }

तुलनित्र का यह संस्करण हमें न केवल पूरे स्ट्रिंग की तुलना करने की अनुमति देगा, बल्कि व्यक्तिगत सबस्ट्रिंग भी करेगा।

स्टेटिक स्ट्रिंग्स का कॉनटेनटेशन

संघनन के लिए, हम स्टैटिक स्ट्रिंग बनाने पर अध्याय के समान वैरिएबल टेम्प्लेट का उपयोग करते हैं। पहली पंक्ति के वर्णों के साथ पहले सरणी को निरूपित करें (अशक्त वर्ण को छोड़कर), फिर दूसरा, और अंत में अशक्त वर्ण को अंत में जोड़ें:

 template<size_t Size1, size_t ... Indexes1, size_t Size2, size_t ... Indexes2> constexpr static_string<Size1 + Size2 - 1> static_string_concat_2( const static_string<Size1>& str1, index_sequence<Indexes1 ...>, const static_string<Size2>& str2, index_sequence<Indexes2 ...>) { return {str1[Indexes1] ..., str2[Indexes2] ..., '\0'}; } template<size_t Size1, size_t Size2> constexpr static_string<Size1 + Size2 - 1> static_string_concat_2( const static_string<Size1>& str1, const static_string<Size2>& str2) { return static_string_concat_2(str1, make_index_sequence<Size1 - 1>{}, str2, make_index_sequence<Size2 - 1>{}); }

हम स्ट्रिंग या स्ट्रिंग शाब्दिकों की एक मनमानी संख्या को समाप्‍त करने के लिए एक वैरिएबल टेम्‍पलेट लागू करते हैं:

 constexpr auto static_string_concat() { return make_static_string(); } template<typename Arg, typename ... Args> constexpr auto static_string_concat(Arg&& arg, Args&& ... args) { return static_string_concat_2(make_static_string(std::forward<Arg>(arg)), static_string_concat(std::forward<Args>(args) ...)); }

स्टेटिक स्ट्रिंग सर्च ऑपरेशन

एक चरित्र की खोज और एक स्थिर स्ट्रिंग में एक विकल्प के संचालन पर विचार करें।

एक स्थिर स्ट्रिंग में एक चरित्र के लिए खोजें

चरित्र खोज विशेष रूप से कठिन नहीं है, सभी सूचकांकों के लिए वर्णों की पुनरावृत्ति की जांच करें और मैच के मामले में पहला सूचकांक लौटाएं। हम खोज की प्रारंभिक स्थिति और मैच की क्रम संख्या निर्धारित करने का अवसर भी देंगे:

 template<size_t Size> constexpr size_t static_string_find(const static_string<Size>& str, char ch, size_t from, size_t nth) { return Size < 2 || from >= Size - 1 ? static_string_npos : str[from] != ch ? static_string_find(str, ch, from + 1, nth) : nth > 0 ? static_string_find(str, ch, from + 1, nth - 1) : from; }

स्थिर static_string_npos इंगित करता है कि खोज असफल रही। हम इसे इस प्रकार परिभाषित करते हैं:

 constexpr size_t static_string_npos = std::numeric_limits<size_t>::max();

इसी तरह, हम एक खोज को विपरीत दिशा में लागू करते हैं:

 template<size_t Size> constexpr size_t static_string_rfind(const static_string<Size>& str, char ch, size_t from, size_t nth) { return Size < 2 || from > Size - 2 ? static_string_npos : str[from] != ch ? static_string_rfind(str, ch, from - 1, nth) : nth > 0 ? static_string_rfind(str, ch, from - 1, nth - 1) : from; }

एक स्थिर स्ट्रिंग में एक चरित्र की घटना का निर्धारण

एक चरित्र की घटना को निर्धारित करने के लिए, बस इसके लिए प्रयास करें:

 template<size_t Size> constexpr bool static_string_contains(const static_string<Size>& str, char ch) { return static_string_find(str, ch) != static_string_npos; }

एक स्थिर स्ट्रिंग में एक चरित्र की घटनाओं की संख्या की गणना करें

घटनाओं की संख्या की गणना तुच्छ रूप से लागू की जाती है:

 template<size_t Size> constexpr size_t static_string_count(const static_string<Size>& str, char ch, size_t index) { return index >= Size - 1 ? 0 : (str[index] == ch ? 1 : 0) + static_string_count(str, ch, index + 1); }

एक स्थिर स्ट्रिंग में एक विकल्प के लिए खोजें

चूंकि यह माना जाता है कि स्थैतिक पंक्तियाँ अपेक्षाकृत छोटी होंगी, हम यहाँ नॉट-मॉरिस-प्रैट एल्गोरिथ्म को लागू नहीं करेंगे, हम सबसे सरल द्विघात एल्गोरिथ्म को लागू करेंगे:

 template<size_t Size, size_t SubSize> constexpr size_t static_string_find(const static_string<Size>& str, const static_string<SubSize>& substr, size_t from, size_t nth) { return Size < SubSize || from > Size - SubSize ? static_string_npos : static_string_compare(str, from, substr, 0, 1, SubSize - 1) != 0 ? static_string_find(str, substr, from + 1, nth) : nth > 0 ? static_string_find(str, substr, from + 1, nth - 1) : from; }

इसी तरह, हम एक खोज को विपरीत दिशा में लागू करते हैं:

 template<size_t Size, size_t SubSize> constexpr size_t static_string_rfind(const static_string<Size>& str, const static_string<SubSize>& substr, size_t from, size_t nth) { return Size < SubSize || from > Size - SubSize ? static_string_npos : static_string_compare(str, from, substr, 0, 1, SubSize - 1) != 0 ? static_string_rfind(str, substr, from - 1, nth) : nth > 0 ? static_string_rfind(str, substr, from - 1, nth - 1) : from; }

एक स्थिर स्ट्रिंग में एक विकल्प की घटना का निर्धारण

सबस्ट्रिंग की घटना को निर्धारित करने के लिए, बस इसके लिए प्रयास करें:

 template<size_t Size, size_t SubSize> constexpr bool static_string_contains(const static_string<Size>& str, const static_string<SubSize>& substr) { return static_string_find(str, substr) != static_string_npos; }

यह निर्धारित करना कि किसी दिए गए सबस्ट्रिंग पर स्टैटिक स्ट्रिंग शुरू होती है / समाप्त होती है

पहले से वर्णित तुलनित्र को लागू करते हुए, हम यह निर्धारित कर सकते हैं कि स्थैतिक स्ट्रिंग दिए गए विकल्प के साथ शुरू होती है:

 template<size_t SubSize, size_t Size> constexpr bool static_string_starts_with(const static_string<Size>& str, const static_string<SubSize>& prefix) { return SubSize > Size ? false : static_string_compare(str, 0, prefix, 0, 1, SubSize - 1) == 0; }

इसी तरह एक स्थिर लाइन को समाप्त करने के लिए:

 template<size_t SubSize, size_t Size> constexpr bool static_string_ends_with(const static_string<Size>& str, const static_string<SubSize>& suffix) { return SubSize > Size ? false : static_string_compare(str, Size - SubSize, suffix, 0, 1, SubSize - 1) == 0; }

स्थिर स्ट्रिंग सबस्ट्रिंग के साथ काम करना

यहां हम एक स्थिर स्ट्रिंग के सबस्ट्रिंग से जुड़े संचालन को देखते हैं।

स्थिर स्ट्रिंग के स्थानापन्न, उपसर्ग और प्रत्यय प्राप्त करना

जैसा कि हमने पहले उल्लेख किया है, एक विकल्प प्राप्त करने के लिए, आपको दिए गए प्रारंभ और अंत सूचक के साथ सूचकांकों का एक क्रम उत्पन्न करना होगा:

 template<size_t Begin, size_t End, size_t ... Indexes> struct make_index_subsequence : make_index_subsequence<Begin, End - 1, End - 1, Indexes ...> {}; template<size_t Pos, size_t ... Indexes> struct make_index_subsequence<Pos, Pos, Indexes ...> : index_sequence<Indexes ...> {};

हम static_assert का उपयोग करके एक स्ट्रिंग की शुरुआत और अंत की जाँच के साथ एक विकल्प प्राप्त करने को लागू करते हैं:

 template<size_t Begin, size_t End, size_t Size> constexpr auto static_string_substring(const static_string<Size>& str) { static_assert(Begin <= End, "Begin is greater than End (Begin > End)"); static_assert(End <= Size - 1, "End is greater than string length (End > Size - 1)"); return make_static_string(str, make_index_subsequence<Begin, End>{}); }

उपसर्ग एक ऐसा विकल्प है जिसकी शुरुआत मूल स्थिर रेखा की शुरुआत के साथ होती है:

 template<size_t End, size_t Size> constexpr auto static_string_prefix(const static_string<Size>& str) { return static_string_substring<0, End>(str); }

प्रत्यय के लिए इसी तरह, केवल अंत मैच:

 template<size_t Begin, size_t Size> constexpr auto static_string_suffix(const static_string<Size>& str) { return static_string_substring<Begin, Size - 1>(str); }

किसी दिए गए सूचकांक में एक स्थिर स्ट्रिंग को दो भागों में विभाजित करना

किसी दिए गए सूचकांक में एक स्थिर स्ट्रिंग को विभाजित करने के लिए, यह उपसर्ग और प्रत्यय वापस करने के लिए पर्याप्त है:

 template<size_t Index, size_t Size> constexpr auto static_string_split(const static_string<Size>& str) { return std::make_pair(static_string_prefix<Index>(str), static_string_suffix<Index + 1>(str)); }

स्टैटिक स्ट्रिंग रिवर्सल

एक स्थिर स्ट्रिंग को उलटने के लिए, हम एक इंडेक्स जनरेटर लिखते हैं जो इंडेक्स को रिवर्स ऑर्डर में उत्पन्न करता है:

 template<size_t Size, size_t ... Indexes> struct make_reverse_index_sequence : make_reverse_index_sequence<Size - 1, Indexes ..., Size - 1> {}; template<size_t ... Indexes> struct make_reverse_index_sequence<0, Indexes ...> : index_sequence<Indexes ...> {};

अब हम एक फ़ंक्शन लागू करते हैं जो स्टैटिक स्ट्रिंग को उलट देता है:

 template<size_t Size> constexpr auto static_string_reverse(const static_string<Size>& str) { return make_static_string(str, make_reverse_index_sequence<Size - 1>{}); }

स्थैतिक स्ट्रिंग हैश गणना

हम निम्न सूत्र का उपयोग करके हैश की गणना करेंगे:

H (s) = (s ₀ + 1) + 33 ⁰ + (s ₁ + 1) 1 33 ¹ + ... + (s _{n - 1} + 1) ⁿ 33 ^{n - 1} + 5381 ⁿ 33 ⁿ mod 2 ⁶⁴

 template<size_t Size> constexpr unsigned long long static_string_hash(const static_string<Size>& str, size_t index) { return index >= Size - 1 ? 5381ULL : static_string_hash(str, index + 1) * 33ULL + str[index] + 1; }

एक संख्या को एक स्थिर स्ट्रिंग में बदलें और इसके विपरीत

इस अध्याय में, हम एक स्थिर स्ट्रिंग को पूर्णांक में बदलने के साथ-साथ व्युत्क्रम को भी देखते हैं। सादगी के लिए, हम मानते हैं कि संख्याओं का प्रतिनिधित्व long long प्रकार से किया जाता है और unsigned long long , ये बड़ी क्षमता के प्रकार होते हैं, अर्थात, वे ज्यादातर मामलों के लिए उपयुक्त होते हैं।

किसी संख्या को स्थिर स्ट्रिंग में बदलें

किसी संख्या को स्थिर स्ट्रिंग में बदलने के लिए, हमें संख्या के सभी अंक प्राप्त करने होंगे, उन्हें संबंधित वर्णों में बदलना होगा और इन वर्णों की एक स्ट्रिंग बनानी होगी।

किसी संख्या के सभी अंकों को प्राप्त करने के लिए, हम इंडेक्स अनुक्रम जनरेटर के समान एक जनरेटर का उपयोग करेंगे। वर्णों के अनुक्रम को परिभाषित करें:

 template<char ... Chars> struct char_sequence {};

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

 template<unsigned long long Value, char ... Chars> struct make_unsigned_int_char_sequence : make_unsigned_int_char_sequence<Value / 10, '0' + Value % 10, Chars ...> {};

यदि वर्तमान संख्या 0 है, तो हम इसे छोड़ देते हैं, अंकों के अनुक्रम को वापस करते हैं, कन्वर्ट करने के लिए और कुछ नहीं है:

 template<char ... Chars> struct make_unsigned_int_char_sequence<0, Chars ...> : char_sequence<Chars ...> {};

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

 template<> struct make_unsigned_int_char_sequence<0> : char_sequence<'0'> {};

कार्यान्वित जनरेटर सकारात्मक संख्याओं के लिए बहुत अच्छा काम करता है, लेकिन नकारात्मक लोगों के लिए उपयुक्त नहीं है। हम शुरुआत में एक और टेम्पलेट पैरामीटर जोड़कर एक नया जनरेटर परिभाषित करते हैं - परिवर्तित संख्या का संकेत:

 template<bool Negative, long long Value, char ... Chars> struct make_signed_int_char_sequence {};

हम ऊपर दिखाए गए अनुसार संख्या को संसाधित करेंगे, लेकिन साइन को ध्यान में रखते हुए:

 template<long long Value, char ... Chars> struct make_signed_int_char_sequence<true, Value, Chars ...> : make_signed_int_char_sequence<true, Value / 10, '0' + -(Value % 10), Chars ...> {}; template<long long Value, char ... Chars> struct make_signed_int_char_sequence<false, Value, Chars ...> : make_signed_int_char_sequence<false, Value / 10, '0' + Value % 10, Chars ...> {};

यहां एक सूक्ष्म बिंदु है, पर ध्यान दें -(Value % 10) । यहां, आप -Value % 10 नहीं दे सकते, क्योंकि नकारात्मक संख्याओं की सीमा सकारात्मकता की सीमा से एक संख्या अधिक है और न्यूनतम संख्या मापांक मान्य मानों के सेट से बाहर आता है।

हम प्रसंस्करण के बाद नंबर को छोड़ देते हैं, यदि यह ऋणात्मक है, तो ऋण चिह्न चिन्ह जोड़ें:

 template<char ... Chars> struct make_signed_int_char_sequence<true, 0, Chars ...> : char_sequence<'-', Chars ...> {}; template<char ... Chars> struct make_signed_int_char_sequence<false, 0, Chars ...> : char_sequence<Chars ...> {};

अलग से, हम शून्य को परिवर्तित करने का ध्यान रखते हैं:

 template<> struct make_signed_int_char_sequence<false, 0> : char_sequence<'0'> {};

अंत में, हम रूपांतरण कार्यों को लागू करते हैं:

 template<unsigned long long Value> constexpr auto uint_to_static_string() { return make_static_string(make_unsigned_int_char_sequence<Value>{}); } template<long long Value> constexpr auto int_to_static_string() { return make_static_string(make_signed_int_char_sequence<(Value < 0), Value>{}); }

स्थिर स्ट्रिंग को संख्या में बदलें

एक स्थिर स्ट्रिंग को एक संख्या में बदलने के लिए, आपको वर्णों को संख्याओं में परिवर्तित करने की आवश्यकता है, और फिर उन्हें जोड़कर, पहले वाली शक्ति से दसियों गुणा गुणा करना होगा। हम सभी क्रियाएं पुनरावर्ती रूप से करते हैं, एक खाली स्ट्रिंग के लिए हम शून्य पर लौटते हैं:

 template<size_t Size> constexpr unsigned long long static_string_to_uint(const static_string<Size>& str, size_t index) { return Size < 2 || index >= Size - 1 ? 0 : (str[index] - '0') + 10ULL * static_string_to_uint(str, index - 1); } template<size_t Size> constexpr unsigned long long static_string_to_uint(const static_string<Size>& str) { return static_string_to_uint(str, Size - 2); }

हस्ताक्षरित संख्याओं को परिवर्तित करने के लिए, ध्यान दें कि ऋणात्मक संख्याएँ ऋण चिह्न से शुरू होती हैं:

 template<size_t Size> constexpr long long static_string_to_int(const static_string<Size>& str, size_t index, size_t first) { return index < first || index >= Size - 1 ? 0 : first == 0 ? (str[index] - '0') + 10LL * static_string_to_int(str, index - 1, first) : -(str[index] - '0') + 10LL * static_string_to_int(str, index - 1, first); } template<size_t Size> constexpr long long static_string_to_int(const static_string<Size>& str) { return Size < 2 ? 0 : str[0] == '-' ? static_string_to_int(str, Size - 2, 1) : static_string_to_int(str, Size - 2, 0); }

पुस्तकालय प्रयोज्यता पर विचार

इस बिंदु पर, लाइब्रेरी का पूरी तरह से उपयोग करना पहले से ही संभव है, लेकिन कुछ बिंदु असुविधाजनक हैं। इस अध्याय में, हम लाइब्रेरी को और अधिक सुविधाजनक बनाने के तरीके के बारे में देखेंगे।

स्थैतिक स्ट्रिंग वस्तु

किसी ऑब्जेक्ट में स्ट्रिंग और कार्यान्वित विधियों को पैक करें। यह छोटी विधि के नाम के उपयोग की अनुमति देगा, साथ ही तुलना ऑपरेटरों को लागू करेगा:

 template<size_t Size> struct static_string { constexpr size_t length() const { return Size - 1; } constexpr size_t size() const { return Size; } constexpr size_t begin() const { return 0; } constexpr size_t end() const { return Size - 1; } constexpr size_t rbegin() const { return Size - 2; } constexpr size_t rend() const { return std::numeric_limits<size_t>::max(); } constexpr bool empty() const { return Size < 2; } constexpr auto reverse() const { return static_string_reverse(*this); } template<size_t Begin, size_t End> constexpr auto substring() const { return static_string_substring<Begin, End>(*this); } template<size_t End> constexpr auto prefix() const { return static_string_prefix<End>(*this); } template<size_t Begin> constexpr auto suffix() const { return static_string_suffix<Begin>(*this); } constexpr size_t find(char ch, size_t from = 0, size_t nth = 0) const { return static_string_find(*this, ch, from, nth); } template<size_t SubSize> constexpr size_t find(const static_string<SubSize>& substr, size_t from = 0, size_t nth = 0) const { return static_string_find(*this, substr, from, nth); } template<size_t SubSize> constexpr size_t find(const char (& substr)[SubSize], size_t from = 0, size_t nth = 0) const { return static_string_find(*this, substr, from, nth); } constexpr size_t rfind(char ch, size_t from = Size - 2, size_t nth = 0) const { return static_string_rfind(*this, ch, from, nth); } template<size_t SubSize> constexpr size_t rfind(const static_string<SubSize>& substr, size_t from = Size - SubSize, size_t nth = 0) const { return static_string_rfind(*this, substr, from, nth); } template<size_t SubSize> constexpr size_t rfind(const char (& substr)[SubSize], size_t from = Size - SubSize, size_t nth = 0) const { return static_string_rfind(*this, substr, from, nth); } constexpr bool contains(char ch) const { return static_string_contains(*this, ch); } template<size_t SubSize> constexpr bool contains(const static_string<SubSize>& substr) const { return static_string_contains(*this, substr); } template<size_t SubSize> constexpr bool contains(const char (& substr)[SubSize]) const { return static_string_contains(*this, substr); } template<size_t SubSize> constexpr bool starts_with(const static_string<SubSize>& prefix) const { return static_string_starts_with(*this, prefix); } template<size_t SubSize> constexpr bool starts_with(const char (& prefix)[SubSize]) const { return static_string_starts_with(*this, prefix); } template<size_t SubSize> constexpr bool ends_with(const static_string<SubSize>& suffix) const { return static_string_ends_with(*this, suffix); } template<size_t SubSize> constexpr bool ends_with(const char (& suffix)[SubSize]) const { return static_string_ends_with(*this, suffix); } constexpr size_t count(char ch) const { return static_string_count(*this, ch); } template<size_t Index> constexpr auto split() const { return static_string_split<Index>(*this); } constexpr unsigned long long hash() const { return static_string_hash(*this); } constexpr char operator[](size_t index) const { return data[index]; } std::string str() const { return to_string(*this); } std::array<const char, Size> data; };

. :

 template<size_t Size1, size_t Size2> constexpr bool operator<(const static_string<Size1>& str1, const static_string<Size2>& str2) { return static_string_compare(str1, str2) < 0; }

> <= >= == !=, . - .

 #define ITOSS(x) int_to_static_string<(x)>() #define UTOSS(x) uint_to_static_string<(x)>() #define SSTOI(x) static_string_to_int((x)) #define SSTOU(x) static_string_to_uint((x))

 constexpr auto hello = make_static_string("Hello"); constexpr auto world = make_static_string("World"); constexpr auto greeting = hello + ", " + world + "!"; // greeting == "Hello, World!"

, :

 constexpr int apples = 5; constexpr int oranges = 7; constexpr auto message = static_string_concat("I have ", ITOSS(apples), " apples and ", ITOSS(oranges), ", so I have ", ITOSS(apples + oranges), " fruits"); // message = "I have 5 apples and 7 oranges, so I have 12 fruits"

 constexpr unsigned long long width = 123456789ULL; constexpr unsigned long long height = 987654321ULL; constexpr auto message = static_string_concat("A rectangle with width ", UTOSS(width), " and height ", UTOSS(height), " has area ", UTOSS(width * height)); // message = "A rectangle with width 123456789 and height 987654321 has area 121932631112635269"

 constexpr long long revenue = 1'000'000LL; constexpr long long costs = 1'200'000LL; constexpr long long profit = revenue - costs; constexpr auto message = static_string_concat("The first quarter has ended with net ", (profit >= 0 ? "profit" : "loss "), " of $", ITOSS(profit < 0 ? -profit : profit)); // message == "The first quarter has ended with net loss of $200000"

URL:

 constexpr auto url = make_static_string("http://www.server.com:8080"); constexpr auto p = url.find("://"); constexpr auto protocol = url.prefix<p>(); // protocol == "http" constexpr auto sockaddr = url.suffix<p + 3>(); constexpr auto hp = sockaddr.split<sockaddr.find(':')>(); constexpr auto host = hp.first; // host == "www.server.com" constexpr int port = SSTOI(hp.second); // port == 8080

 constexpr auto str = make_static_string("Hello"); for (size_t i = str.begin(); i != str.end(); ++i) //  std::cout << str[i]; std::cout << std::endl; // Hello for (size_t i = str.rbegin(); i != str.rend(); --i) //  std::cout << str[i]; std::cout << std::endl; // olleH

संदर्भ

, , github

, .

Update

_ss :

 template<typename Char, Char ... Chars> constexpr basic_static_string<Char, sizeof ... (Chars) + 1> operator"" _ss() { return {Chars ..., static_cast<Char>('\0')}; };

make_static_string() , :

 constexpr auto hello_world = "Hello"_ss + " World"; if ("Hello" < "World"_ss) { ... } constexpr auto hash = "VeryLongString"_ss.hash();

Char char:

 template<typename Char, size_t Size> struct basic_static_string { // ... std::array<const Char, Size> data; };

char whar_t, , concat, :

 template<size_t Size> using static_string_t = basic_static_string<char, Size>; template<size_t Size> using static_wstring_t = basic_static_string<wchar_t, Size>; using static_string = basic_static_string<char, 0>; using static_wstring = basic_static_string<wchar_t, 0>;

"" :

 constexpr auto wide_string = L"WideString"_ss; constexpr int apples = 5; constexpr int oranges = 7; constexpr int fruits = apples + oranges; constexpr auto str3 = static_wstring::concat(L"I have ", ITOSW(apples), L" apples and ", ITOSW(oranges), L" oranges, so I have ", ITOSW(fruits), L" fruits"); static_assert(str3 == L"I have 5 apples and 7 oranges, so I have 12 fruits", ""); std::wcout << str3 << std::endl;

size(), size() length() , sizeof():

 constexpr auto ss1 = "Hello"_ss; static_assert(ss1.length() == 5, ""); static_assert(ss1.size() == 5, ""); static_assert(sizeof(ss1) == 6, "");

github
.

Update 2

AndreySu , :

 #include <iostream> using namespace std; template<typename Char, Char ... Chars> struct static_string{}; template<typename Char, Char ... Chars1, Char ... Chars2> constexpr static_string<Char, Chars1 ..., Chars2 ... > operator+( const static_string<Char, Chars1 ... >& str1, const static_string<Char, Chars2 ... >& str2) { return static_string<Char, Chars1 ..., Chars2 ...>{}; } template<typename Char, Char ch, Char ... Chars> std::basic_ostream<Char>& operator<<(std::basic_ostream<Char>& bos, const static_string<Char, ch, Chars ...>& str) { bos << ch << static_string<Char, Chars ... >{}; return bos; } template<typename Char> std::basic_ostream<Char>& operator<<(std::basic_ostream<Char>& bos, const static_string<Char>& str) { return bos; } template<typename Char, Char ... Chars> constexpr static_string<Char, Chars ... > operator"" _ss() { return static_string<Char, Chars ... >{}; }; int main() { constexpr auto str1 = "abc"_ss; constexpr auto str2 = "def"_ss; constexpr auto str = str1 + str2 + str1; std::cout << str << std::endl; return 0; }

, , - .

आधुनिक सी ++ में संकलन चरण में तार के साथ काम करना