पर 2017/11/11 , आईएसओ सी ++ समिति अपनाया हर्ब Sutter के लिए के प्रस्ताव <=> "अंतरिक्ष यान" तीन तरह तुलना ऑपरेटर कि करने के लिए जोड़ा गया था नई सुविधाओं में से एक के रूप में सी ++ 20 । सुसंगत तुलना सटर, मौरर और ब्राउन नामक पत्र में नए डिजाइन की अवधारणाओं को प्रदर्शित किया गया है। प्रस्ताव के अवलोकन के लिए, यहां लेख का एक अंश दिया गया है:
व्यंजक <=> b एक ऐसी वस्तु लौटाता है जो <0 की तुलना करता है तो <b , तुलना करता है > 0 यदि a> b , और तुलना करता है == 0 यदि a और b समान / समतुल्य है।
सामान्य मामला: टाइप वाई के साथ अपने टाइप एक्स के लिए सभी तुलना लिखने के लिए , सदस्यवार शब्दार्थ के साथ, बस लिखें:
auto X::operator<=>(const Y&) =default;
उन्नत मामले: टाइप वाई के साथ अपने टाइप एक्स के लिए सभी तुलना लिखने के लिए , बस ऑपरेटर लिखें <=> जो वाई लेता है , यदि वांछित है, तो सदस्यवार शब्दार्थ प्राप्त करने के लिए = डिफ़ॉल्ट का उपयोग कर सकते हैं
और उपयुक्त श्रेणी प्रकार लौटा सकते हैं:
- एक लौटें _ordering अगर आपके प्रकार स्वाभाविक रूप से समर्थन करता है < , और हम कुशलतापूर्वक सममित उत्पन्न करेंगे < , > , <= , > = , == , और
=! ; अन्यथा एक असमानता लौटाते हैं , और हम कुशलता से सममित == और ! = उत्पन्न करेंगे ।
- वापसी strong_ अगर आपके प्रकार के लिए एक == ख का तात्पर्य च (क) == च (ख) (प्रतिस्थापन, जहां च केवल तुलना-मुख्य राज्य है कि सार्वजनिक उपयोग करते हुए पहुँचा जा सकता है पढ़ता स्थिरांक सदस्य), अन्यथा लौट
weak_ ।
तुलना श्रेणियाँ
पांच तुलना श्रेणियों को std::प्रकारों के रूप में परिभाषित किया गया है , जिनमें से प्रत्येक में निम्नलिखित पूर्वनिर्धारित मूल्य हैं:
+--------------------------------------------------------------------+
| | Numeric values | Non-numeric |
| Category +-----------------------------------+ |
| | -1 | 0 | +1 | values |
+------------------+------+------------+---------------+-------------+
| strong_ordering | less | equal | greater | |
| weak_ordering | less | equivalent | greater | |
| partial_ordering | less | equivalent | greater | unordered |
| strong_equality | | equal | nonequal | |
| weak_equality | | equivalent | nonequivalent | |
+------------------+------+------------+---------------+-------------+
इन प्रकारों के बीच निहित रूपांतरण इस प्रकार हैं:
strong_orderingमूल्यों के साथ { less, equal, greater} परोक्ष में धर्मान्तरित:
weak_orderingमूल्यों के साथ { less, equivalent, greater}partial_orderingमूल्यों के साथ { less, equivalent, greater}strong_equalityमूल्यों के साथ { unequal, equal, unequal}weak_equalityमूल्यों के साथ { nonequivalent, equivalent, nonequivalent}
weak_orderingमूल्यों के साथ { less, equivalent, greater} परोक्ष में धर्मान्तरित:
partial_orderingमूल्यों के साथ { less, equivalent, greater}weak_equalityमूल्यों के साथ { nonequivalent, equivalent, nonequivalent}
partial_orderingमूल्यों के साथ { less, equivalent, greater, unordered} परोक्ष में धर्मान्तरित:
weak_equalityमूल्यों के साथ { nonequivalent, equivalent, nonequivalent, nonequivalent}
strong_equalityमानों के साथ { } equal, unequalस्पष्ट रूप से इसमें रूपांतरित होता है:
weak_equalityमूल्यों के साथ { equivalent, nonequivalent}
तीन तरह से तुलना
<=>टोकन शुरू की है। वर्ण अनुक्रम पुराने स्रोत कोड में, <=>tokenizes <= >। उदाहरण के लिए, X<&Y::operator<=>अपने अर्थ को बनाए रखने के लिए एक स्थान जोड़ने की आवश्यकता है।
अधिभार संचालक <=>एक तीन-तरफा तुलनात्मक कार्य है और पूर्ववर्ती से अधिक <और निम्नतर है <<। यह एक प्रकार का रिटर्न देता है जिसकी तुलना शाब्दिक के खिलाफ की जा सकती है 0लेकिन अन्य रिटर्न प्रकारों की अनुमति दी जाती है जैसे कि अभिव्यक्ति टेम्पलेट्स का समर्थन करना। <=>भाषा में और मानक पुस्तकालय में परिभाषित सभी ऑपरेटर 5 पूर्वोक्त std::तुलना श्रेणी प्रकारों में से एक को लौटाते हैं।
भाषा प्रकारों के लिए, निम्नलिखित अंतर्निहित <=>समान-प्रकार की तुलनाएं प्रदान की जाती हैं। सभी विवश हैं , सिवाय इसके कि जहां अन्यथा उल्लेख किया गया है। इन तुलनाओं को स्केलर प्रमोशन / रूपांतरणों का उपयोग करके पूरी तरह से लागू नहीं किया जा सकता है।
- के लिए
bool, अभिन्न, और सूचक प्रकार, <=>रिटर्न strong_ordering।
- सूचक प्रकारों के लिए, विभिन्न cv- योग्यता और व्युत्पन्न-आधार रूपांतरणों को एक सजातीय निर्मित में आह्वान करने की अनुमति है
<=>, और अंतर्निहित विषम हैं operator<=>(T*, nullptr_t)। केवल एक ही वस्तु / आवंटन के लिए बिंदुओं की तुलना स्थिर अभिव्यक्ति है।
- मूलभूत फ़्लोटिंग बिंदु प्रकारों के लिए,
<=>रिटर्न partial_ordering, और बड़े फ़्लोटिंग पॉइंट प्रकार के तर्कों को व्यापक रूप से लागू किया जा सकता है।
- गणना के लिए,
<=>गणना के अंतर्निहित प्रकार के समान ही रिटर्न देता है <=>।
- के लिए
nullptr_t, <=>रिटर्न strong_orderingऔर हमेशा पैदावार equal।
- Copyable सरणियों के लिए,
T[N] <=> T[N]के रूप में एक ही प्रकार के रिटर्न Tकी <=>और प्रदर्शन lexicographical elementwise तुलना। <=>अन्य सरणियों के लिए नहीं है ।
- के लिए
voidवहाँ नहीं है <=>।
इस ऑपरेटर के आंतरिक कामकाज को बेहतर ढंग से समझने के लिए, कृपया मूल पेपर पढ़ें । यह वही है जो मैंने खोज इंजन का उपयोग करके पाया है।
