C ++ 20 में तुलना संचालन

कोलोन में बैठक पारित हो गई है, C ++ 20 मानक को कम या ज्यादा समाप्त रूप में (विशेष नोटों की उपस्थिति तक) कम कर दिया गया है, और मैं आगामी नवाचारों में से एक के बारे में बात करना चाहूंगा। यह एक तंत्र है जिसे आमतौर पर ऑपरेटर <=> कहा जाता है (मानक इसे "तीन-तरफा तुलना ऑपरेटर" के रूप में परिभाषित करता है, लेकिन इसमें अनौपचारिक उपनाम "स्पेसशिप" है), लेकिन मेरा मानना ​​है कि इसका दायरा बहुत व्यापक है।

हमारे पास सिर्फ एक नया ऑपरेटर नहीं होगा - तुलनाओं के शब्दार्थ भाषा के स्तर पर महत्वपूर्ण बदलावों से गुजरेंगे।

यहां तक ​​कि अगर आप इस लेख से बाहर कुछ और प्राप्त नहीं कर सकते हैं, तो इस तालिका को याद रखें:

अब हमारे पास एक नया ऑपरेटर होगा, <=> , लेकिन, इससे भी महत्वपूर्ण बात यह है कि ऑपरेटरों को अब व्यवस्थित किया जाता है। मूल ऑपरेटर हैं और व्युत्पन्न ऑपरेटर हैं - प्रत्येक समूह की अपनी क्षमताएं हैं।

हम इन विशेषताओं के बारे में संक्षेप में बात करेंगे और निम्नलिखित अनुभागों में अधिक विस्तार से विचार करेंगे।

बुनियादी ऑपरेटरों को उलटा किया जा सकता है (यानी मापदंडों के रिवर्स ऑर्डर के साथ फिर से लिखा गया है)। व्युत्पन्न बयानों को इसी आधार विवरण के माध्यम से फिर से लिखा जा सकता है। न तो रूपांतरित और न ही लिखित उम्मीदवार नए कार्य उत्पन्न करते हैं, वे केवल स्रोत कोड स्तर पर प्रतिस्थापन होते हैं और उम्मीदवारों के विस्तारित सेट से चुने जाते हैं। उदाहरण के लिए, अभिव्यक्ति <a 9 को अब a.operator <=> (9) <0 , और अभिव्यक्ति 10! = B as के रूप में मूल्यांकन किया जा सकता है ! ऑपरेटर == (b, 10) । इसका मतलब यह है कि एक या दो ऑपरेटरों के साथ फैलाना संभव होगा, जहां समान व्यवहार को प्राप्त करने के लिए, अब मैन्युअल रूप से 2, 4, 6, या यहां तक ​​कि 12 ऑपरेटरों को लिखना आवश्यक है। सभी संभावित परिवर्तनों की तालिका के साथ नियमों का एक संक्षिप्त अवलोकन नीचे प्रस्तुत किया जाएगा।

दोनों मूल और व्युत्पन्न ऑपरेटरों को डिफ़ॉल्ट के रूप में परिभाषित किया जा सकता है। बुनियादी ऑपरेटरों के मामले में, इसका मतलब है कि ऑपरेटर को घोषणा के क्रम में प्रत्येक सदस्य पर लागू किया जाएगा; व्युत्पन्न ऑपरेटरों के मामले में, पुनर्लेखन उम्मीदवारों का उपयोग किया जाएगा।

यह ध्यान दिया जाना चाहिए कि ऐसा कोई परिवर्तन नहीं है जिसमें एक प्रकार का ऑपरेटर (यानी, समानता या आदेश) किसी अन्य प्रकार के ऑपरेटर के संदर्भ में व्यक्त किया जा सकता है। दूसरे शब्दों में, हमारी तालिका के कॉलम किसी भी तरह से एक-दूसरे पर निर्भर नहीं हैं। अभिव्यक्ति == बी का मूल्यांकन कभी भी ऑपरेटर के रूप में नहीं किया जाएगा <=> (ए, बी) == 0 स्पष्ट रूप से (लेकिन, निश्चित रूप से, कुछ भी आपको अपने ऑपरेटर को परिभाषित करने से रोकता नहीं है == ऑपरेटर का उपयोग करना <=> अगर आप चाहते हैं)।

एक छोटे उदाहरण पर विचार करें जिसमें हम दिखाते हैं कि नई कार्यक्षमता को लागू करने से पहले और बाद में कोड कैसा दिखता है। हम एक स्ट्रिंग प्रकार लिखेंगे जो केस-संवेदी नहीं है, CIString , जिसकी वस्तुओं की एक दूसरे के साथ और चार कास्ट * के साथ तुलना की जा सकती है।

C ++ 17 में, हमारे कार्य के लिए, हमें 18 तुलनात्मक कार्य लिखने होंगे:

class CIString { string s; public: friend bool operator==(const CIString& a, const CIString& b) { return assize() == bssize() && ci_compare(asc_str(), bsc_str()) == 0; } friend bool operator< (const CIString& a, const CIString& b) { return ci_compare(asc_str(), bsc_str()) < 0; } friend bool operator!=(const CIString& a, const CIString& b) { return !(a == b); } friend bool operator> (const CIString& a, const CIString& b) { return b < a; } friend bool operator>=(const CIString& a, const CIString& b) { return !(a < b); } friend bool operator<=(const CIString& a, const CIString& b) { return !(b < a); } friend bool operator==(const CIString& a, const char* b) { return ci_compare(asc_str(), b) == 0; } friend bool operator< (const CIString& a, const char* b) { return ci_compare(asc_str(), b) < 0; } friend bool operator!=(const CIString& a, const char* b) { return !(a == b); } friend bool operator> (const CIString& a, const char* b) { return b < a; } friend bool operator>=(const CIString& a, const char* b) { return !(a < b); } friend bool operator<=(const CIString& a, const char* b) { return !(b < a); } friend bool operator==(const char* a, const CIString& b) { return ci_compare(a, bsc_str()) == 0; } friend bool operator< (const char* a, const CIString& b) { return ci_compare(a, bsc_str()) < 0; } friend bool operator!=(const char* a, const CIString& b) { return !(a == b); } friend bool operator> (const char* a, const CIString& b) { return b < a; } friend bool operator>=(const char* a, const CIString& b) { return !(a < b); } friend bool operator<=(const char* a, const CIString& b) { return !(b < a); } }; 

C ++ 20 में, आप केवल 4 कार्य कर सकते हैं:

 class CIString { string s; public: bool operator==(const CIString& b) const { return s.size() == bssize() && ci_compare(s.c_str(), bsc_str()) == 0; } std::weak_ordering operator<=>(const CIString& b) const { return ci_compare(s.c_str(), bsc_str()) <=> 0; } bool operator==(char const* b) const { return ci_compare(s.c_str(), b) == 0; } std::weak_ordering operator<=>(const char* b) const { return ci_compare(s.c_str(), b) <=> 0; } }; 

मैं आपको बताता हूं कि सभी का क्या अर्थ है, अधिक विस्तार से, लेकिन सबसे पहले, आइए थोड़ा पीछे चलते हैं और याद करते हैं कि तुलनाओं ने C ++ 20 मानक तक कैसे काम किया।

C ++ 98 से C ++ 17 तक के मानकों में तुलना

भाषा के निर्माण के बाद से तुलनात्मक संचालन बहुत ज्यादा नहीं बदला है। हमारे छह संचालक थे: == ; =!, < , > , <= और > = । मानक उनमें से प्रत्येक को अंतर्निहित प्रकारों के लिए परिभाषित करता है, लेकिन सामान्य तौर पर वे समान नियमों का पालन करते हैं। किसी भी @ b अभिव्यक्ति (जहां @ छह तुलनात्मक संचालकों में से एक है) का मूल्यांकन करते समय, संकलक सदस्य कार्यों, नि: शुल्क कार्यों और अंतर्निहित @ नाम वाले उम्मीदवारों के लिए खोज करता है, जिसे निर्दिष्ट क्रम में टाइप ए या बी के साथ बुलाया जा सकता है। उनमें से सबसे उपयुक्त उम्मीदवार का चयन किया जाता है। वह सब है। वास्तव में, सभी ऑपरेटरों ने एक ही तरह से काम किया: ऑपरेशन <<< से अलग नहीं था।

नियमों का ऐसा सरल सेट सीखना आसान है। सभी ऑपरेटर बिल्कुल स्वतंत्र और समतुल्य हैं। इससे कोई फर्क नहीं पड़ता कि हम मनुष्यों के बीच मूलभूत संबंध के बारे में क्या जानते हैं == और ! = संचालन। भाषा के संदर्भ में, यह एक है और एक ही है। हम मुहावरों का उपयोग करते हैं। उदाहरण के लिए, हम ऑपरेटर को परिभाषित करते हैं ! = Through == :

 bool operator==(A const&, A const&); bool operator!=(A const& lhs, A const& rhs) { return !(lhs == rhs); } 

इसी तरह, ऑपरेटर के माध्यम से < हम अन्य सभी संबंध ऑपरेटरों को परिभाषित करते हैं। हम इन मुहावरों का उपयोग करते हैं, क्योंकि भाषा के नियमों के बावजूद, हम वास्तव में सभी छह ऑपरेटरों के समकक्ष नहीं मानते हैं। हम स्वीकार करते हैं कि उनमें से दो बुनियादी हैं ( == और < ), और उनके माध्यम से अन्य सभी पहले से ही व्यक्त किए गए हैं।

वास्तव में, मानक टेम्पलेट लाइब्रेरी पूरी तरह से इन दो ऑपरेटरों पर बनाई गई है, और शोषित कोड में बड़ी संख्या में प्रकार उनमें से केवल एक या दोनों की परिभाषाएं हैं।

हालांकि, दो कारणों से आधार की भूमिका के लिए < ऑपरेटर बहुत उपयुक्त नहीं है।

पहले, अन्य रिश्ते ऑपरेटरों को इसके माध्यम से व्यक्त करने की गारंटी नहीं दी जा सकती है। हां, a> b का अर्थ बिलकुल b <a के समान है , लेकिन यह सत्य नहीं है कि a = = b का अर्थ बिल्कुल वैसा ही है ! (B <a) । यदि ट्राइकोटॉमी संपत्ति है जिसमें अंतिम दो अभिव्यक्तियाँ समतुल्य होंगी जिसमें किन्हीं दो मूल्यों के लिए केवल तीन कथनों में से एक सत्य है: a <b , a == b या a> b । एक ट्राइकोटॉमी की उपस्थिति में, ए <= बी का मतलब है कि हम पहले या दूसरे मामले से निपट रहे हैं ... और यह उस कथन के बराबर है जो हम तीसरे मामले से नहीं निपट रहे हैं। इसलिए (ए = बी) ==! (ए> बी) ==! (बी <ए) ।

लेकिन क्या होगा अगर रवैया ट्राइकोटॉमी की संपत्ति का मालिक नहीं है? यह आंशिक आदेश संबंधों की विशेषता है। एक क्लासिक उदाहरण फ्लोटिंग पॉइंट नंबर है जिसके लिए कोई भी ऑपरेशन 1.f <NaN , 1.f == NaN और 1.f> NaN गलत है । इसलिए, 1.f <= NaN भी एक झूठ देता है, लेकिन एक ही समय में ! (NaN <1.f) सच है ।

मूल ऑपरेटरों के माध्यम से सामान्य शब्दों में <= ऑपरेटर को लागू करने का एकमात्र तरीका दोनों संचालन को (== बी) के रूप में चित्रित करना है (ए <बी) , जो एक बड़ा कदम है, अगर हमें अभी भी रैखिक क्रम से निपटना है, तब से एक फ़ंक्शन को नहीं बुलाया जाएगा, लेकिन दो (उदाहरण के लिए, "abc..xyz9" <= "abc" ..xyz1 " को (" abc..xyz9 "==" abc..xyz1 ")" ("abc..xyz9" <"abc..xyz1") के रूप में और संपूर्ण पंक्ति की तुलना करने के लिए दो बार लिखना होगा ।

दूसरी बात, लेक्सिकोग्राफिक तुलनाओं में इसके उपयोग की ख़ासियत के कारण ऑपरेटर < मूल भूमिका के लिए बहुत उपयुक्त नहीं है। प्रोग्रामर अक्सर यह गलती करते हैं:

 struct A { T t; U u; bool operator==(A const& rhs) const { return t == rhs.t && u == rhs.u; } bool operator< (A const& rhs) const { return t < rhs.t && u < rhs.u; } }; 

तत्वों के संग्रह के लिए == ऑपरेटर को परिभाषित करने के लिए, प्रत्येक सदस्य को एक बार == लागू करना पर्याप्त है, लेकिन यह < ऑपरेटर के साथ काम नहीं करेगा। इस कार्यान्वयन के दृष्टिकोण से, सेट A {1, 2} और A {2, 1} को समतुल्य माना जाएगा (क्योंकि उनमें से कोई भी अन्य से कम नहीं है)। इसे ठीक करने के लिए, अंतिम को छोड़कर प्रत्येक सदस्य को दो बार < ऑपरेटर लागू करें:

 bool operator< (A const& rhs) const { if (t < rhs.t) return true; if (rhs.t < t) return false; return u < rhs.u; } 

अंत में, विषम वस्तुओं की तुलना के सही संचालन की गारंटी देने के लिए - अर्थात्। यह सुनिश्चित करने के लिए कि अभिव्यक्तियाँ a == 10 और 10 == का एक ही मतलब है - वे आमतौर पर तुलनात्मक कार्यों को मुफ्त में लिखने की सलाह देते हैं। वास्तव में, यह आमतौर पर ऐसी तुलनाओं को लागू करने का एकमात्र तरीका है। यह असुविधाजनक है क्योंकि, सबसे पहले, आपको इस सिफारिश के अनुपालन की निगरानी करनी होगी, और दूसरी बात, आपको आमतौर पर ऐसे कार्यों को अधिक सुविधाजनक कार्यान्वयन के लिए छिपे हुए दोस्तों की घोषणा करनी होगी (अर्थात वर्ग निकाय के अंदर)।

ध्यान दें कि विभिन्न प्रकारों की वस्तुओं की तुलना करते समय ऑपरेटर == (X, int) लिखना हमेशा आवश्यक नहीं होता है; वे ऐसे मामलों का भी अर्थ लगा सकते हैं जहाँ int को X निहित किया जा सकता है।

आइए नियमों को संक्षेप में C ++ 20 मानक पर लाएं:

• सभी बयानों को उसी तरह से संभाला जाता है।
• हम कार्यान्वयन की सुविधा के लिए मुहावरों का उपयोग करते हैं। ऑपरेटरों == और < हम मूल मुहावरों के लिए लेते हैं और शेष रिश्ते ऑपरेटरों को उनके माध्यम से व्यक्त करते हैं।
• बस ऑपरेटर < आधार की भूमिका के लिए बहुत उपयुक्त नहीं है।
• निश्शुल्क कार्यों के रूप में विषम वस्तुओं की तुलना लिखना महत्वपूर्ण (और अनुशंसित) है।

नया मूल आदेश ऑपरेटर: <=>

C ++ 20 में तुलना के काम में सबसे महत्वपूर्ण और ध्यान देने योग्य परिवर्तन एक नए ऑपरेटर - ऑपरेटर <=> का है , जो तीन-तरफ़ा तुलना ऑपरेटर है।

हम पहले से ही तीन तरह की तुलनाओं से परिचित हैं फ़ंक्शन सी में सीएमसी / स्ट्रैम्प और बुनियादी_स्ट्रीमिंग :: तुलना () सी ++ में। वे सभी प्रकार के इंट का मान लौटाते हैं, जो एक मनमाना सकारात्मक संख्या द्वारा दर्शाया जाता है यदि पहला तर्क दूसरे से अधिक है, 0 यदि वे समान हैं, और एक मनमाना नकारात्मक संख्या अन्यथा।

"स्पेसशिप" ऑपरेटर एक अंतर मूल्य नहीं लौटाता है, लेकिन एक तुलना श्रेणियों में से एक वस्तु, जिसका मूल्य तुलना की गई वस्तुओं के बीच संबंध के प्रकार को दर्शाता है। तीन मुख्य श्रेणियां हैं:

• strong_ordering : एक रेखीय क्रम संबंध जिसमें समानता का अर्थ है तत्वों की परस्पर विनिमय क्षमता (यानी (ए <=> b) == strong_ordering :: बराबर का अर्थ है कि f (a) == (b) सभी उपयुक्त कार्यों को धारण करता है f "उपयुक्त फ़ंक्शन" शब्द को जानबूझकर एक स्पष्ट परिभाषा नहीं दी गई है, लेकिन इनमें ऐसे कार्य शामिल नहीं हैं जो अपने तर्कों के पते या क्षमता () वेक्टर की वापसी करते हैं, आदि हम केवल "आवश्यक" गुणों में रुचि रखते हैं, जो बहुत अस्पष्ट है, लेकिन सशर्त रूप से हो सकता है मान लें कि हम प्रकार के मूल्य के बारे में बात कर रहे हैं। वेक्टर का मूल्य इसमें निहित है मी एलिमेंट्स, लेकिन उसका पता नहीं, आदि)। इस श्रेणी में निम्नलिखित मूल्य शामिल हैं: strong_ordering :: अधिक , मजबूत_ऑर्डरिंग :: समान और मजबूत_ऑर्डरिंग :: कम ।
• weak_ordering : एक रैखिक क्रम संबंध जिसमें समानता केवल एक निश्चित समता वर्ग को परिभाषित करता है। एक क्लासिक उदाहरण केस असंवेदनशील स्ट्रिंग तुलना है, जब दो ऑब्जेक्ट कमजोर_ऑर्डरिंग हो सकते हैं :: समतुल्य , लेकिन कड़ाई से बराबर नहीं होते हैं (यह मूल्य नाम में समतुल्य शब्द के प्रतिस्थापन की व्याख्या करता है)।
• आंशिक_संक्रमण : आंशिक क्रम संबंध। इस श्रेणी में, एक और मान को अधिक , समतुल्य, और कम (जैसे कि कमजोर_ऑर्डरिंग में ) जोड़ा जाता है - अनियंत्रित ("अव्यवस्थित")। इसका उपयोग एक प्रकार की प्रणाली में आंशिक आदेश संबंधों को व्यक्त करने के लिए किया जा सकता है: 1.f <=> NaN मान को आंशिक_ऑर्डरिंग :: अनियंत्रित करता है ।

आप मुख्य रूप से strong_ordering श्रेणी के साथ काम करेंगे; यह भी डिफ़ॉल्ट रूप से उपयोग के लिए इष्टतम श्रेणी है। उदाहरण के लिए, 2 <=> 4 मजबूत_ऑर्डरिंग :: कम , और 3 <=> -1 रिटर्न मजबूत_ऑर्डरिंग :: अधिक ।

उच्चतर क्रम की श्रेणियों को कमज़ोर क्रम की श्रेणियों में कम किया जा सकता है (यानी, strong_ordering कमजोर_आकर्षक करने के लिए अतिरेक है )। इस मामले में, वर्तमान प्रकार का संबंध संरक्षित है (यानी, मजबूत_ऑर्डरिंग :: समान रूप से कमजोर_रोडिंग :: बराबर ) में बदल जाता है।

तुलना श्रेणियों के मूल्यों की तुलना शाब्दिक 0 से की जा सकती है (किसी भी int के साथ नहीं और int के साथ 0 के बराबर नहीं, लेकिन बस शाब्दिक 0 के साथ) छह तुलनात्मक संचालकों में से एक का उपयोग करते हुए:

 strong_ordering::less < 0 // true strong_ordering::less == 0 // false strong_ordering::less != 0 // true strong_ordering::greater >= 0 // true partial_ordering::less < 0 // true partial_ordering::greater > 0 // true // unordered -  ,   //       partial_ordering::unordered < 0 // false partial_ordering::unordered == 0 // false partial_ordering::unordered > 0 // false 

यह शाब्दिक 0 के साथ तुलना करने के लिए धन्यवाद है कि हम संबंध ऑपरेटरों को लागू कर सकते हैं: एक @ बी इन ऑपरेटरों में से प्रत्येक के लिए (ए <=> बी) @ 0 के बराबर है।

उदाहरण के लिए, 2 <4 की गणना (2 <=> 4) <0 के रूप में की जा सकती है, जो strong_ordering :: कम <0 में बदल जाती है और मान को सही देती है ।

<=> ऑपरेटर बेस ऑपरेटर की भूमिका को फिट करता है < ऑपरेटर से बेहतर है, क्योंकि यह बाद की दोनों समस्याओं को खत्म करता है।

सबसे पहले, एक <= b की अभिव्यक्ति आंशिक आदेश के साथ (<=> b) <= 0 के बराबर होने की गारंटी है। दो अनियंत्रित मानों के लिए, एक <=> बी आंशिक रूप से मूल्य दे देगा :: अनियंत्रित , और आंशिक_आयोजित :: अनियंत्रित <= 0 गलत देगा , जो कि हमें चाहिए। यह संभव है क्योंकि <=> मूल्यों की अधिक किस्में वापस कर सकते हैं: उदाहरण के लिए, आंशिक_ऑर्डरिंग श्रेणी में चार संभावित मान शामिल हैं। प्रकार बूल का एक मूल्य केवल सही या गलत हो सकता है , इसलिए इससे पहले कि हम आदेशित और अनियंत्रित मूल्यों की तुलना के बीच अंतर न कर सकें।

स्पष्टता के लिए, एक आंशिक क्रम संबंध का एक उदाहरण पर विचार करें जो फ्लोटिंग पॉइंट संख्याओं से संबंधित नहीं है। मान लीजिए कि हम एक NaN राज्य को एक int प्रकार में जोड़ना चाहते हैं, जहां NaN सिर्फ एक मूल्य है जो एक ऑर्डर किए गए जोड़े को शामिल नहीं करता है जिसमें कोई मान शामिल नहीं है। आप इसे उपयोग करने के लिए std :: वैकल्पिक का उपयोग करके कर सकते हैं:

 struct IntNan { std::optional<int> val = std::nullopt; bool operator==(IntNan const& rhs) const { if (!val || !rhs.val) { return false; } return *val == *rhs.val; } partial_ordering operator<=>(IntNan const& rhs) const { if (!val || !rhs.val) { //  unordered   //     return partial_ordering::unordered; } // <=>   strong_ordering  int, //        partial_ordering return *val <=> *rhs.val; } }; IntNan{2} <=> IntNan{4}; // partial_ordering::less IntNan{2} <=> IntNan{}; // partial_ordering::unordered //     .    IntNan{2} < IntNan{4}; // true IntNan{2} < IntNan{}; // false IntNan{2} == IntNan{}; // false IntNan{2} <= IntNan{}; // false 

<= ऑपरेटर सही मान लौटाता है क्योंकि अब हम भाषा के स्तर पर ही अधिक जानकारी व्यक्त कर सकते हैं।

दूसरे, सभी आवश्यक जानकारी प्राप्त करने के लिए, यह एक बार लागू करने के लिए पर्याप्त है <=> , जो लेक्सोग्राफ़िक के कार्यान्वयन की सुविधा प्रदान करता है:

 struct A { T t; U u; bool operator==(A const& rhs) const { return t == rhs.t && u == rhs.u; } strong_ordering operator<=>(A const& rhs) const { //    //  t.   != 0 (..  t // ),    //   if (auto c = t <=> rhs.t; c != 0) return c; //     //    return u <=> rhs.u; }; 

P0515 , ऑपरेटर को जोड़ने के लिए मूल वाक्य <=>, अधिक विस्तृत चर्चा के लिए देखें ।

नई ऑपरेटर सुविधाएँ

हम अपने निपटान में सिर्फ एक नया ऑपरेटर नहीं प्राप्त करते हैं। अंत में, यदि संरचना ए की घोषणा के साथ ऊपर दिखाए गए उदाहरण में केवल यह कहा गया है कि x <y के बजाय अब हमें लिखना है (x <=> y) <0 हर बार, कोई भी इसे पसंद नहीं करेगा।

C ++ 20 में तुलनाओं को हल करने का तंत्र पुराने दृष्टिकोण से अलग-अलग है, लेकिन यह परिवर्तन सीधे दो बुनियादी तुलना ऑपरेटरों की नई अवधारणा से संबंधित है: == और <=> । यदि पहले यह एक मुहावरा था ( == और <के माध्यम से रिकॉर्डिंग), जो हमने उपयोग किया था, लेकिन जिसके बारे में संकलक को पता नहीं था, अब वह इस अंतर को समझेगा।

एक बार फिर, मैं एक तालिका दूंगा जो आपने पहले ही लेख की शुरुआत में देखी थी:

प्रत्येक मूल और व्युत्पन्न ऑपरेटरों को एक नई क्षमता प्राप्त हुई, जिसे मैं आगे कुछ शब्द कहूंगा।

बुनियादी ऑपरेटरों का उलटा

एक उदाहरण के रूप में, एक प्रकार लें जिसे केवल int के साथ तुलना किया जा सकता है:

 struct A { int i; explicit A(int i) : i(i) { } bool operator==(int j) const { return i == j; } }; 

पुराने नियमों के दृष्टिकोण से, यह आश्चर्यजनक नहीं है कि अभिव्यक्ति a == 10 काम करती है और a.operator == (10) का मूल्यांकन करती है।

लेकिन क्या 10 == ए के बारे में? C ++ 17 में, इस अभिव्यक्ति को एक स्पष्ट वाक्यविन्यास त्रुटि माना जाएगा। ऐसा कोई ऑपरेटर नहीं है। इस कोड को काम करने के लिए, आपको एक सममित ऑपरेटर == लिखना होगा, जो पहले इंट का मान लेगा, और फिर ए ... और इसे लागू करने के लिए एक नि: शुल्क फ़ंक्शन के रूप में होना होगा।

C ++ 20 में, मूल ऑपरेटरों को उलटा किया जा सकता है। 10 == ए के लिए, कंपाइलर को एक उम्मीदवार ऑपरेटर मिलेगा == (ए, इंट) (वास्तव में, यह एक सदस्य फ़ंक्शन है, लेकिन स्पष्टता के लिए, मैं इसे एक मुफ्त फ़ंक्शन के रूप में यहां लिखता हूं), और फिर इसके अलावा - मापदंडों के रिवर्स ऑर्डर के साथ एक संस्करण, अर्थात्। । ऑपरेटर == (इंट, ए) । यह दूसरा उम्मीदवार हमारी अभिव्यक्ति (और आदर्श रूप से) के साथ मेल खाता है, इसलिए हम इसे चुनेंगे। C ++ 20 में अभिव्यक्ति 10 == a का मूल्यांकन a.operator == (10) के रूप में किया जाता है। संकलक समझता है कि समानता सममित है।

अब हम अपने प्रकार का विस्तार करेंगे ताकि इसकी तुलना न केवल समानता ऑपरेटर के माध्यम से की जा सके, बल्कि ऑर्डर करने वाले ऑपरेटर के माध्यम से भी की जा सके:

 struct A { int i; explicit A(int i) : i(i) { } bool operator==(int j) const { return i == j; } strong_ordering operator<=>(int j) const { return i <=> j; } }; 

फिर, एक अभिव्यक्ति <=> 42 ठीक काम करता है और पुराने नियमों के अनुसार गणना की जाती है। एओपरेटर <=> (42) के रूप में , लेकिन 42 <=> सी ++ 17 के दृष्टिकोण से गलत होगा, भले ही ऑपरेटर <। => भाषा में पहले से मौजूद है। लेकिन C ++ 20 में, ऑपरेटर <=> , ऑपरेटर == की तरह, सममित है: यह उल्टे उम्मीदवारों को पहचानता है। 42 <=> ए के लिए, एक सदस्य फ़ंक्शन ऑपरेटर <=> (ए, इंट) पाया जाएगा (फिर से, मैं इसे यहां मुफ्त फ़ंक्शन के रूप में अधिक स्पष्टता के लिए लिख रहा हूं), साथ ही एक सिंथेटिक उम्मीदवार ऑपरेटर <=> (इंट, ए) । यह उलटा संस्करण बिल्कुल हमारी अभिव्यक्ति से मेल खाता है - हम इसे चुनते हैं।

हालाँकि, 42 <=> a.operator <=> (42) के रूप में गणना नहीं की गई है। यह गलत होगा। यह अभिव्यक्ति 0 <=> a.operator <=> (42) का मूल्यांकन करती है। यह पता लगाने की कोशिश करें कि यह प्रविष्टि सही क्यों है।

यह ध्यान रखना महत्वपूर्ण है कि संकलक कोई नया कार्य नहीं बनाता है। 10 == ए की गणना करते समय , नया ऑपरेटर ऑपरेटर == (इंट, ए) दिखाई नहीं दिया, और जब 42 <=> ए , ऑपरेटर <=> (इंट, ए) की गणना नहीं हुई। उल्टे उम्मीदवारों के माध्यम से सिर्फ दो अभिव्यक्तियों को फिर से लिखा गया है। मैं दोहराता हूं: कोई नया कार्य नहीं बनता है।

यह भी ध्यान दें कि मापदंडों के रिवर्स ऑर्डर के साथ एक रिकॉर्ड केवल मूल ऑपरेटरों के लिए उपलब्ध है, लेकिन डेरिवेटिव के लिए यह नहीं है। वह है:

 struct B { bool operator!=(int) const; }; b != 42; // ok   C++17,   C++20 42 != b; //    C++17,   C++20 

व्युत्पन्न ऑपरेटरों का पुनर्लेखन

आइए संरचना ए के साथ अपने उदाहरण पर वापस जाएं:

 struct A { int i; explicit A(int i) : i(i) { } bool operator==(int j) const { return i == j; } strong_ordering operator<=>(int j) const { return i <=> j; } }; 

अभिव्यक्ति ए! = 17 लें । C ++ 17 में, यह एक सिंटैक्स त्रुटि है क्योंकि ऑपरेटर! = ऑपरेटर मौजूद नहीं है। हालाँकि, C ++ 20 में, व्युत्पन्न तुलना ऑपरेटरों के साथ अभिव्यक्ति के लिए, संकलक संबंधित बुनियादी ऑपरेटरों की खोज करेगा और उनके माध्यम से व्युत्पन्न तुलनाओं को व्यक्त करेगा।

हम जानते हैं कि गणित में, ऑपरेशन ! = अनिवार्य रूप से मतलब नहीं है == । अब यह संकलक को पता है। ए! = 17 की अभिव्यक्ति के लिए , वह न केवल ऑपरेटर के लिए दिखेगा ! = ऑपरेटर्स , बल्कि ऑपरेटर == (और, पिछले उदाहरणों में, उल्टे ऑपरेटर == )। इस उदाहरण के लिए, हमें एक समानता ऑपरेटर मिला जो लगभग हमें सूट करता है - हमें बस इसे वांछित शब्दार्थ के अनुसार फिर से लिखना होगा: a =! = 17 की गणना इस प्रकार की जाएगी ! (A == 17) ।

इसी तरह, 17! = ए की गणना की जाती है ! एऑपरेटर == (17) , जो एक पुनर्लेखन और उलटा संस्करण दोनों है।

आदेश देने वाले ऑपरेटरों के लिए भी इसी तरह के बदलाव किए जाते हैं। यदि हमने <9 लिखा है , तो हम ऑपरेटर को खोजने के लिए (असफल) कोशिश करेंगे < , और मूल उम्मीदवारों पर भी विचार करें: ऑपरेटर <=> । संबंध ऑपरेटरों के लिए संबंधित प्रतिस्थापन इस तरह दिखता है: एक @ बी (जहां @ संबंध ऑपरेटरों में से एक है) की गणना (<=> b) @ 0 के रूप में की जाती है । हमारे मामले में, a.operator <=> (9) <0 । इसी तरह, 9 <= a की गणना 0 <= a.operator <=> (9) के रूप में की जाती है ।

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

उपरोक्त मुझे निम्नलिखित सलाह की ओर ले जाता है:

बुनियादी विकल्प केवल : अपने प्रकार में केवल मूल ऑपरेटरों (== और <=>) को परिभाषित करें।

चूंकि बुनियादी ऑपरेटर तुलनाओं के पूरे सेट को देते हैं, इसलिए यह केवल उन्हें परिभाषित करने के लिए पर्याप्त है। इसका मतलब है कि आपको विभिन्न प्रकार की वस्तुओं (12 के बजाय) की तुलना करने के लिए एक ही प्रकार की वस्तुओं (6 के बजाय, अब के रूप में) और केवल 2 ऑपरेटरों की तुलना करने के लिए केवल 2 ऑपरेटरों की आवश्यकता है। यदि आपको केवल समानता संचालन की आवश्यकता है, तो विभिन्न प्रकार की वस्तुओं (4 के बजाय) की तुलना करने के लिए एक ही प्रकार (2 के बजाय) और 1 फ़ंक्शन की वस्तुओं की तुलना करने के लिए केवल 1 फ़ंक्शन लिखें। Std :: sub_match क्लास एक चरम मामला है: C ++ 17 में यह 42 तुलनात्मक ऑपरेटरों का उपयोग करता है, और C ++ 20 में यह केवल 8 का उपयोग करता है, जबकि कार्यक्षमता किसी भी तरह से पीड़ित नहीं है।

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

उम्मीदवारों को खोजने के लिए विशेष नियम

जैसा कि मैंने पहले ही उल्लेख किया है, C ++ 17 में @ b के लिए उम्मीदवारों की खोज निम्नलिखित सिद्धांत के अनुसार की गई थी: हम सभी ऑपरेटर @ ऑपरेटर पाते हैं और उनमें से सबसे उपयुक्त एक का चयन करते हैं।

C ++ 20 उम्मीदवारों के एक विस्तारित सेट का उपयोग करता है। अब हम सभी ऑपरेटर @ खोजेंगे । @@ के लिए आधार ऑपरेटर हो (यह एक ही ऑपरेटर हो सकता है)। हम सभी ऑपरेटर @@ भी पाते हैं और उनमें से प्रत्येक के लिए हम इसका उल्टा संस्करण जोड़ते हैं। इन सभी उम्मीदवारों से, हम सबसे उपयुक्त का चयन करते हैं।

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

अब हमारे पास अधिक संभावित उम्मीदवार हैं, और इसलिए अधिक अनिश्चितता है। निम्नलिखित उदाहरण पर विचार करें:

 struct C { bool operator==(C const&) const; bool operator!=(C const&) const; }; bool check(C x, C y) { return x != y; } 

C ++ 17 में, हमारे पास x के लिए केवल एक उम्मीदवार था ! = Y , और अब तीन हैं: x.operator! = (Y) ; X.operator == (y) और ! Y.operator == (x) । क्या चुनना है? वे सभी समान हैं! (नोट: उम्मीदवार y.operator! = (X) मौजूद नहीं है, क्योंकि केवल मूल ऑपरेटर ही उलटे हो सकते हैं)।

इस अनिश्चितता को दूर करने के लिए दो अतिरिक्त नियम पेश किए गए हैं। असंबद्ध उम्मीदवार अभिसरण के लिए बेहतर हैं; . , x.operator!=(y) «» !x.operator==(y) , «» !y.operator==(x) . , «» .

: operator@@ . . , .

-. — (, x < y , — (x <=> y) < 0 ), (, x <=> y void - , DSL), . . , bool ( : operator== bool , ?)

उदाहरण के लिए:

 struct Base { friend bool operator<(const Base&, const Base&); // #1 friend bool operator==(const Base&, const Base&); }; struct Derived : Base { friend void operator<=>(const Derived&, const Derived&); // #2 }; bool f(Derived d1, Derived d2) { return d1 < d2; } 

d1 < d2 : #1 #2 . — #2 , , , . , d1 < d2 (d1 <=> d2) < 0 . , void 0 — , . , - , #1 .

, , C++17, . , - . :

• ( )
• ,
• , .

, . .

. , , , , , ( ). , :

« » , , .. a < b 0 < (b <=> a) , , , .

C++17 . . :

 struct A { T t; U u; V v; bool operator==(A const& rhs) const { return t == rhs.t && u == rhs.u && v == rhs.v; } bool operator!=(A const& rhs) const { return !(*this == rhs); } bool operator< (A const& rhs) const { //    ,     , //     ?:  &&/|| if (t < rhs.t) return true; if (rhs.t < t) return false; if (u < rhs.u) return true; if (rhs.u < u) return false; return v < rhs.v; } bool operator> (A const& rhs) const { return rhs < *this; } bool operator<=(A const& rhs) const { return !(rhs < *this); } bool operator>=(A const& rhs) const { return !(*this < rhs); } }; 

- std::tie() , .

, : :

 struct A { T t; U u; V v; bool operator==(A const& rhs) const { return t == rhs.t && u == rhs.u && v == rhs.v; } strong_ordering operator<=>(A const& rhs) const { //   T if (auto c = t <=> rhs.t; c != 0) return c; // ...  U if (auto c = u <=> rhs.u; c != 0) return c; // ...  V return v <=> rhs.v; } }; 

. <=> < . , . c != 0 , , ( ), .

. C++20 , :

 struct A { T t; U u; V v; bool operator==(A const& rhs) const = default; strong_ordering operator<=>(A const& rhs) const = default; }; 

, . , :

 struct A { T t; U u; V v; bool operator==(A const& rhs) const = default; auto operator<=>(A const& rhs) const = default; }; 

. , , :

 struct A { T t; U u; V v; auto operator<=>(A const& rhs) const = default; }; 

, , . : operator== , operator<=> .

C++20: . . , , , .

PVS-Studio , <=> . , -. , , (. " "). ++ .

PVS-Studio <, :

 bool operator< (A const& rhs) const { return t < rhs.t && u < rhs.u; } 

. , - . .

: Comparisons in C++20 .