रॉकेट साइंस के साथ अपने कोड को सरल बनाएं: C ++ 20 का स्पेसशिप ऑपरेटर

C ++ 20 एक नया ऑपरेटर जोड़ता है, जिसे प्यार से "स्पेसशिप" ऑपरेटर कहा जाता है: <=> । हमारे बहुत ही साइमन ब्रांड द्वारा कुछ समय पहले पोस्ट किया गया था कि इस नए ऑपरेटर के बारे में कुछ जानकारी के साथ-साथ यह क्या है और क्या करता है, के बारे में कुछ जानकारी प्रदान करता है। इस पोस्ट का लक्ष्य इस अजीब नए ऑपरेटर और इसके संबंधित समकक्ष के कुछ ठोस अनुप्रयोगों का पता लगाना है, operator== (बेहतर के लिए, इसे बदल दिया गया है!), हर रोज़ कोड में इसके उपयोग के लिए कुछ दिशानिर्देश प्रदान करते हुए।

तुलना

निम्नलिखित की तरह कोड देखना कोई असामान्य बात नहीं है:

 struct IntWrapper {  int value;  constexpr IntWrapper(int value): value{value} { }  bool operator==(const IntWrapper& rhs) const { return value == rhs.value; }  bool operator!=(const IntWrapper& rhs) const { return !(*this == rhs);    }  bool operator<(const IntWrapper& rhs)  const { return value < rhs.value;  }  bool operator<=(const IntWrapper& rhs) const { return !(rhs < *this);    }  bool operator>(const IntWrapper& rhs)  const { return rhs < *this;        }  bool operator>=(const IntWrapper& rhs) const { return !(*this < rhs);    } }; 

नोट: ईगल-आईडेड रीडर्स यह नोटिस करेंगे कि यह वास्तव में कम क्रिया है, क्योंकि यह प्री-सी ++ 20 कोड में होना चाहिए क्योंकि ये फ़ंक्शन वास्तव में सभी को गैर-मित्र होना चाहिए, इसके बारे में और बाद में।

यह सुनिश्चित करने के लिए कि मेरा प्रकार एक ही प्रकार के कुछ के बराबर है लिखने के लिए बहुत सारे बॉयलरप्लेट कोड है। ठीक है, ठीक है, हम थोड़ी देर के लिए इससे निपटते हैं। इसके बाद कोई व्यक्ति जो इसे लिखता है:

 constexpr bool is_lt(const IntWrapper& a, const IntWrapper& b) {  return a < b; } int main() {  static_assert(is_lt(0, 1)); } 

पहली बात जो आप देखेंगे वह यह है कि यह कार्यक्रम संकलित नहीं करेगा।

error C3615: constexpr function 'is_lt' cannot result in a constant expression

आह! समस्या यह है कि हम अपने तुलनात्मक फ़ंक्शन, ड्रैट पर constexpr भूल गए हैं! तो एक जाता है और सभी तुलनात्मक संचालकों में constexpr करता है। कुछ दिनों बाद कोई जाता है और एक is_gt हेल्पर जोड़ता है, लेकिन सभी नोटिस संचालकों के पास अपवाद विनिर्देश नहीं होते हैं और 5 ओवरलोड में से प्रत्येक में noexcept जोड़ने की एक ही थकाऊ प्रक्रिया से noexcept है।

यह वह जगह है जहां C ++ 20 का नया स्पेसशिप ऑपरेटर हमारी मदद करने के लिए कदम उठाता है। आइए देखें कि मूल IntWrapper को C ++ 20 दुनिया में कैसे लिखा जा सकता है:

 #include <compare> struct IntWrapper {  int value;  constexpr IntWrapper(int value): value{value} { }  auto operator<=>(const IntWrapper&) const = default; }; 

पहला अंतर जो आप देख सकते हैं, वह है <compare> का नया समावेश। हमारे तुलनात्मक प्रकार के लिए उपयुक्त प्रकार को वापस करने के लिए स्पेसशिप ऑपरेटर के लिए आवश्यक तुलना प्रकार के सभी प्रकार के साथ कंपाइलर को जोड़ने के लिए <compare> हेडर जिम्मेदार है। ऊपर दिए गए स्निपेट में, रिटर्न प्रकार auto को std::strong_ordering ।

न केवल हमने 5 अधकचरी लाइनों को हटा दिया, बल्कि हमें कुछ भी परिभाषित करने की आवश्यकता नहीं है, कंपाइलर हमारे लिए करता है! हमारा is_lt अपरिवर्तित बना हुआ है और अभी भी काम कर रहा है जबकि हम अभी भी स्पष्ट रूप से निर्दिष्ट नहीं हुए हैं कि हमारे डिफ़ॉल्ट operator<=> में निर्दिष्ट नहीं है। यह अच्छी तरह से और अच्छा है, लेकिन कुछ लोग अपने सिर को खरोंच कर रहे हैं क्यों is_lt को अभी भी संकलित करने की अनुमति है, भले ही यह अंतरिक्ष यान ऑपरेटर का उपयोग बिल्कुल भी नहीं करता है। आइए इस सवाल का जवाब तलाशते हैं।

अभिव्यक्त करने वाले भाव

C ++ 20 में, संकलक को एक नई अवधारणा से परिचित कराया गया है जिसे "पुन: लिखित" अभिव्यक्तियों के लिए संदर्भित किया गया है। स्पेसशिप ऑपरेटर, operator== के साथ, पहले दो उम्मीदवारों के बीच फिर से लिखित अभिव्यक्ति के अधीन हैं। अभिव्यक्ति पुनर्लेखन के अधिक ठोस उदाहरण के लिए, आइए is_lt में is_lt गए उदाहरण को is_lt ।

ओवरलोड रिज़ॉल्यूशन के दौरान कंपाइलर व्यवहार्य उम्मीदवारों के एक सेट से चयन करने जा रहा है, जो सभी उस ऑपरेटर से मेल खाते हैं जिसकी हम तलाश कर रहे हैं। रिलेशनल और समतुल्यता संचालन के मामले में उम्मीदवार की एकत्रित करने की प्रक्रिया बहुत कम बदली जाती है, जहां कंपाइलर को भी विशेष लिखित और संश्लेषित उम्मीदवारों ( [over.match.oper] /3.4 ) को इकट्ठा करना होगा।

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

आप खुद से पूछ सकते हैं कि यह पुनर्लेखन अभिव्यक्ति वैध और सही क्यों है। अभिव्यक्ति की शुद्धता वास्तव में शब्दार्थ से उपजी है जिसे स्पेसशिप ऑपरेटर प्रदान करता है। <=> एक तीन-तरफा तुलना है जिसका तात्पर्य है कि आपको न केवल एक द्विआधारी परिणाम मिलता है, बल्कि एक आदेश (ज्यादातर मामलों में) और यदि आपके पास कोई आदेश है तो आप किसी भी संबंधपरक संचालन के संदर्भ में उस आदेश को व्यक्त कर सकते हैं। एक त्वरित उदाहरण, C ++ 20 में अभिव्यक्ति 4 <=> 5 आपको परिणाम std::strong_ordering::less । std::strong_ordering::less परिणाम का तात्पर्य है कि 4 न केवल 5 से अलग है, बल्कि यह उस मूल्य से कड़ाई से कम है, इससे ऑपरेशन लागू होता है (4 <=> 5) < 0 हमारे परिणाम का वर्णन करने के लिए सही और सटीक है।

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

सिंथेसाइज़िंग एक्सप्रेशन

पाठकों ने ऊपर "संश्लेषित" अभिव्यक्तियों के सूक्ष्म उल्लेख पर ध्यान दिया हो सकता है और वे इस ऑपरेटर पुनर्लेखन प्रक्रिया में भी एक भूमिका निभाते हैं। एक अलग विधेय समारोह पर विचार करें:

 constexpr bool is_gt_42(const IntWrapper& a) {  return 42 < a; } 

यदि हम IntWrapper लिए अपनी मूल परिभाषा का उपयोग करते हैं IntWrapper यह कोड संकलित नहीं करेगा।

error C2677: binary '<': no global operator found which takes type 'const IntWrapper' (or there is no acceptable conversion)

यह पूर्व-सी ++ 20 भूमि में समझ में आता है, और इस समस्या को हल करने का तरीका IntWrapper कुछ अतिरिक्त friend कार्यों को IntWrapper जो IntWrapper बाएं हाथ की ओर ले जाते हैं। यदि आप उस नमूने को C ++ 20 संकलक और हमारे C ++ 20 परिभाषा वाले IntWrapper साथ बनाने का प्रयास करते हैं, तो आप देख सकते हैं कि यह, फिर से, "बस काम करता है" - प्रमुख सिर खरोंच। आइए जांच करें कि ऊपर दिए गए कोड को अभी भी C ++ 20 में संकलित करने की अनुमति क्यों है।

अधिभार संकल्प के दौरान संकलक भी इकट्ठा करेगा कि मानक "संश्लेषित" उम्मीदवारों के रूप में संदर्भित होता है, या फिर से बदले गए मापदंडों के क्रम के साथ एक फिर से लिखे गए अभिव्यक्ति। संकलक के ऊपर के उदाहरण में पुन: लिखित अभिव्यक्ति (42 <=> a) < 0 का उपयोग करने का प्रयास करेंगे, लेकिन यह पाएंगे कि बाएं हाथ की ओर को संतुष्ट करने के लिए IntWrapper से कोई रूपांतरण नहीं है ताकि फिर से लिखित अभिव्यक्ति को गिरा दिया जाए। कंपाइलर "संश्लेषित" अभिव्यक्ति 0 < (a <=> 42) को भी IntWrapper है और पाता है कि int में IntWrapper से इसके परिवर्तित कंस्ट्रक्टर के माध्यम से रूपांतरण होता है इसलिए इस उम्मीदवार का उपयोग किया जाता है।

संश्लेषित अभिव्यक्तियों का लक्ष्य उन कार्यों को करने के लिए बायलरप्लेट को लिखने की आवश्यकता की गड़बड़ी से बचना है, जहां आपकी वस्तु को अन्य प्रकारों से परिवर्तित किया जा सकता है। संश्लेषित अभिव्यक्तियों को 0 @ (b <=> a) लिए सामान्यीकृत किया जाता है।

अधिक जटिल प्रकार

कंपाइलर-जनरेटेड स्पेसशिप ऑपरेटर कक्षाओं के एकल सदस्यों पर नहीं रुकता है, यह आपके प्रकारों के भीतर सभी उप-ऑब्जेक्ट्स के लिए तुलना का एक सही सेट उत्पन्न करेगा:

 struct Basics {  int i;  char c;  float f;  double d;  auto operator<=>(const Basics&) const = default; }; struct Arrays {  int ai[1];  char ac[2];  float af[3];  double ad[2][2];  auto operator<=>(const Arrays&) const = default; }; struct Bases : Basics, Arrays {  auto operator<=>(const Bases&) const = default; }; int main() {  constexpr Bases a = { { 0, 'c', 1.f, 1. },                        { { 1 }, { 'a', 'b' }, { 1.f, 2.f, 3.f }, { { 1., 2. }, { 3., 4. } } } };  constexpr Bases b = { { 0, 'c', 1.f, 1. },                        { { 1 }, { 'a', 'b' }, { 1.f, 2.f, 3.f }, { { 1., 2. }, { 3., 4. } } } };  static_assert(a == b);  static_assert(!(a != b));  static_assert(!(a < b));  static_assert(a <= b);  static_assert(!(a > b));  static_assert(a >= b); } 

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

एक बतख की तरह दिखता है, एक बतख की तरह तैरता है, और operator== तरह क्वैक्स operator==

मानकीकरण समिति के कुछ बहुत ही चतुर लोगों ने देखा कि स्पेसशिप ऑपरेटर हमेशा तत्वों की कोई तुलनात्मक तुलना नहीं करेगा। लेक्सिकोग्राफिक तुलनाओं के बिना प्रदर्शन के विशेष रूप से समानता ऑपरेटर के साथ अक्षम उत्पन्न कोड हो सकते हैं।

विहित उदाहरण दो तारों की तुलना कर रहा है। यदि आपके पास स्ट्रिंग "foobar" और आप इसे == का उपयोग करते हुए स्ट्रिंग "foo" से तुलना करते हैं, तो वह उम्मीद करेगा कि ऑपरेशन लगभग स्थिर हो। कुशल स्ट्रिंग तुलना एल्गोरिथ्म इस प्रकार है:

• पहले दो तारों के आकार की तुलना करें, यदि आकार अलग-अलग false , अन्यथा
• दो तारों के प्रत्येक तत्व के माध्यम से एकसमान में कदम रखें और तब तक तुलना करें जब तक कि एक अलग या अंत नहीं हो जाता है, परिणाम लौटाएं।

स्पेसशिप ऑपरेटर नियमों के तहत हमें प्रत्येक तत्व पर गहरी तुलना के साथ शुरू करने की आवश्यकता है जब तक कि हम एक अलग नहीं पाते हैं। "foobar" और "foo" के हमारे उदाहरण में 'b' तुलना '\0' करने पर ही आप अंत में false ।

इसका मुकाबला करने के लिए एक पेपर था, P1185R2 जो संकलक के लिए एक तरह से विवरण देता है और operator== स्वतंत्र रूप से स्पेसशिप ऑपरेटर को फिर से लिखने और उत्पन्न करने के लिए। हमारे IntWrapper इस प्रकार लिखा जा सकता है:

 #include <compare> struct IntWrapper {  int value;  constexpr IntWrapper(int value): value{value} { }  auto operator<=>(const IntWrapper&) const = default;  bool operator==(const IntWrapper&) const = default; }; 

बस एक और कदम ... हालांकि, अच्छी खबर है; आपको वास्तव में ऊपर दिए गए कोड को लिखने की आवश्यकता नहीं है, क्योंकि बस auto operator<=>(const IntWrapper&) const = default कंपाइलर के लिए अलग-अलग और अधिक कुशल - operator== को उत्पन्न करने के लिए पर्याप्त है!

कंपाइलर == और != लिए विशिष्ट रूप से थोड़े बदले हुए "रीराइट" नियम को लागू करता है, जहां इन ऑपरेटरों को operator== संदर्भ में फिर से लिखा जाता है और operator<=> नहीं। इसका मतलब यह है कि != अनुकूलन से भी बहुत लाभ मिलता है।

पुराना कोड नहीं टूटेगा

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

 struct IntWrapper {  int value;  constexpr IntWrapper(int value): value{value} { }  auto operator<=>(const IntWrapper&) const = default;  bool operator<(const IntWrapper& rhs) const { return value < rhs.value; } }; constexpr bool is_lt(const IntWrapper& a, const IntWrapper& b) {  return a < b; } 

यहाँ उत्तर है, आपने नहीं किया। C ++ में ओवरलोड रिज़ॉल्यूशन मॉडल में यह क्षेत्र है जहां सभी उम्मीदवार लड़ाई करते हैं, और इस विशिष्ट लड़ाई में हमारे पास 3 उम्मीदवार हैं:

• IntWrapper::operator<(const IntWrapper& a, const IntWrapper& b)
• IntWrapper::operator<=>(const IntWrapper& a, const IntWrapper& b)

(फिर से लिखा)

• IntWrapper::operator<=>(const IntWrapper& b, const IntWrapper& a)

(समन्वित)

यदि हम C ++ 17 में अधिभार संकल्प नियमों को स्वीकार करते हैं, तो उस कॉल का परिणाम अस्पष्ट होगा, लेकिन संकलक को इस स्थिति को सबसे तार्किक अधिभार को हल करने की अनुमति देने के लिए C ++ 20 अधिभार संकल्प नियमों को बदल दिया गया था।

अधिभार संकल्प का एक चरण है जहां संकलक को एक श्रृंखला टाईब्रेकर प्रदर्शन करना होगा। C ++ 20 में, एक नया टाईब्रेकर है जिसमें कहा गया है कि हमें उन IntWrapper::operator< को प्राथमिकता देनी चाहिए जो पुन: लिखित या संश्लेषित नहीं हैं, इससे हमारा अधिभार IntWrapper::operator< सबसे अच्छा उम्मीदवार IntWrapper::operator< और अस्पष्टता का समाधान करता है। यह वही मशीनरी संश्लेषित उम्मीदवारों को नियमित रूप से लिखित अभिव्यक्तियों पर स्टंपिंग करने से रोकती है।

विचार बंद करना

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

हम आपसे बाहर जाने और स्पेसशिप ऑपरेटर की कोशिश करने का आग्रह करते हैं, यह अभी विजुअल स्टूडियो 2019 में /std:c++latest तहत उपलब्ध है! एक नोट के रूप में, P1185R2 के माध्यम से पेश किए गए परिवर्तन विज़ुअल स्टूडियो 2019 संस्करण 16.2 में उपलब्ध होंगे। कृपया ध्यान रखें कि स्पेसशिप ऑपरेटर C ++ 20 का हिस्सा है और कुछ बदलावों के अधीन है जब तक कि C ++ 20 को अंतिम रूप नहीं दिया जाता है।

हमेशा की तरह, हम आपकी प्रतिक्रिया का स्वागत करते हैं। Visualcpp@microsoft.com पर ई-मेल के माध्यम से, Twitter @visualc , या Facebook के माध्यम से Microsoft Visual Cpp पर कोई भी टिप्पणी भेजने में संकोच न करें। इसके अलावा, ट्विटर @starfreakclone पर मेरा अनुसरण करने के लिए स्वतंत्र महसूस करें।

यदि आप वीएस 2019 में एमएसवीसी के साथ अन्य समस्याओं का सामना करते हैं, तो कृपया हमें इंस्टॉलर या विजुअल स्टूडियो आईडीई से रिपोर्ट समस्या विकल्प के माध्यम से बताएं। सुझाव या बग रिपोर्ट के लिए, देवकॉम के माध्यम से हमें बताएं ।