C ++ में अभिव्यक्ति श्रेणियाँ

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

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

थोड़ा सा इतिहास

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

lvalue = rvalue; 

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

बंजारन बचाव के लिए पहुंचता है

सी ++ में, अभिव्यक्ति श्रेणियों की शब्दावली काफी दृढ़ता से विकसित हुई है, खासकर सी ++ 11 मानक को अपनाने के बाद, जिसने प्रतिद्वंद्विता लिंक और चालित अर्थ विज्ञान की अवधारणाओं को पेश किया। नई शब्दावली के उद्भव का इतिहास स्ट्रैसपुप के लेख "न्यू" मूल्य शब्दावली में दिलचस्प रूप से वर्णित है।

नई, अधिक कठोर शब्दावली 2 गुणों पर आधारित है:

• पहचान की उपस्थिति ( पहचान ) - अर्थात् , कुछ पैरामीटर जिसके द्वारा यह समझा जा सकता है कि दो अभिव्यक्तियाँ एक ही इकाई को संदर्भित करती हैं या नहीं (उदाहरण के लिए, स्मृति में एक पता);
• स्थानांतरित करने की क्षमता (से स्थानांतरित किया जा सकता है ) - आंदोलन के शब्दार्थ का समर्थन करता है।

आइडेंटिटी-एक्सप्रेसिंग एक्सप्रेशन को ग्लव्यू ( सामान्यीकृत मान ) शब्द के तहत सामान्यीकृत किया जाता है, घूमते हुए एक्सप्रेशंस को रिवेल्यू कहा जाता है। इन दो गुणों के संयोजन ने अभिव्यक्ति की 3 मुख्य श्रेणियों की पहचान की है:

वास्तव में, C ++ 17 मानक ने कॉपी एलिसन की अवधारणा को पेश किया - ऐसी परिस्थितियों को औपचारिक बनाना जहां संकलक वस्तुओं को कॉपी करने और आगे बढ़ने से बचना चाहिए। इस संबंध में, प्रचलन को जरूरी नहीं माना जा सकता है। विवरण और उदाहरण यहां देखे जा सकते हैं । हालांकि, यह अभिव्यक्ति की श्रेणियों की सामान्य योजना की समझ को प्रभावित नहीं करता है।

आधुनिक C ++ मानक में, श्रेणी संरचना को इस तरह की योजना के रूप में प्रस्तुत किया जाता है:

आइए हम सामान्य रूप से श्रेणियों के गुणों के साथ-साथ प्रत्येक श्रेणी में शामिल भाषा के भावों की जांच करें। मैं तुरंत ध्यान देता हूं कि प्रत्येक श्रेणी के लिए नीचे दी गई अभिव्यक्तियों की सूचियों को पूर्ण नहीं माना जा सकता है; अधिक सटीक और विस्तृत जानकारी के लिए, सीधे C ++ मानक देखें।

glvalue

Glvalue श्रेणी में अभिव्यक्तियाँ निम्नलिखित गुण हैं:

• व्यापक रूप से प्रचलन में परिवर्तित किया जा सकता है;
• बहुरूपी हो सकता है, अर्थात्, उनके लिए एक स्थिर और गतिशील प्रकार की अवधारणाएं समझ में आती हैं;
• प्रकार शून्य का नहीं हो सकता - यह सीधे पहचान होने की संपत्ति से होता है, क्योंकि प्रकार शून्य की अभिव्यक्ति के लिए ऐसा कोई पैरामीटर नहीं है जो उन्हें एक दूसरे से अलग करता हो;
• एक अपूर्ण प्रकार हो सकता है , उदाहरण के लिए, आगे की घोषणा के रूप में (यदि किसी विशेष अभिव्यक्ति के लिए अनुमति हो)।

rvalue

प्रतिद्वंद्वी श्रेणी में अभिव्यक्तियाँ निम्नलिखित गुण हैं:

• आपको स्मृति में व्याप्त पता नहीं मिल सकता है - यह सीधे पहचान संपत्ति की कमी से होता है;
• एक असाइनमेंट या कंपाउंड असाइनमेंट स्टेटमेंट के बाईं ओर नहीं हो सकता है;
• एक निरंतर अंतराल लिंक या rvalue लिंक को इनिशियलाइज़ करने के लिए इस्तेमाल किया जा सकता है, जबकि ऑब्जेक्ट का जीवनकाल लिंक के जीवनकाल तक विस्तारित होता है;
• यदि एक फ़ंक्शन के रूप में उपयोग किया जाता है, जिसमें 2 अतिभारित संस्करण होते हैं: एक निरंतर अंतराल संदर्भ और दूसरा एक संदर्भ संदर्भ को स्वीकार करता है, तो उस संस्करण को स्वीकार किया जाता है, जिसे संदर्भ संदर्भ चुना जाता है। यह वह संपत्ति है जिसका उपयोग चाल शब्दार्थ को लागू करने के लिए किया जाता है:

 class A { public: A() = default; A(const A&) { std::cout << "A::A(const A&)\n"; } A(A&&) { std::cout << "A::A(A&&)\n"; } }; ......... A a; A b(a); //  A(const A&) A c(std::move(a)); //  A(A&&) 

तकनीकी रूप से, A && एक प्रतिद्वंद्विता है और इसका उपयोग एक निरंतर अंतराल संदर्भ और एक अंतराल संदर्भ दोनों को शुरू करने के लिए किया जा सकता है। लेकिन इस संपत्ति के लिए धन्यवाद, कोई अस्पष्टता नहीं है, एक रचनाकार विकल्प स्वीकार किया जाता है जो एक संदर्भ संदर्भ स्वीकार करता है।

lvalue

विशेषताएं:

• सभी चमक गुण (ऊपर देखें);
• आप इसका पता ले सकते हैं (बिल्ट-इन यूनेरी ऑपरेटर का उपयोग करके);
• परिवर्तनशील अंतराल असाइनमेंट ऑपरेटर या कंपाउंड असाइनमेंट ऑपरेटरों के बाईं ओर हो सकते हैं;
• एक अंतराल (दोनों स्थिर और गैर-स्थिर) के संदर्भ को इनिशियलाइज़ करने के लिए इस्तेमाल किया जा सकता है।

निम्नलिखित भाव लवलीन श्रेणी के हैं:

• किसी भी प्रकार के एक चर, कार्य या वर्ग क्षेत्र का नाम। भले ही चर एक संदर्भ है, अभिव्यक्ति में इस चर का नाम एक अंतराल है ;

 void func() {} ......... auto* func_ptr = &func; // :     auto& func_ref = func; // :     int&& rrn = int(123); auto* pn = &rrn; // :    auto& rn = rrn; // :  lvalue- 

• एक फ़ंक्शन या एक अतिभारित ऑपरेटर को कॉल करना जो एक लैवल्यू संदर्भ देता है, या एक लैवल्यू संदर्भ के प्रकार में रूपांतरण की अभिव्यक्ति;
• अंतर्निहित असाइनमेंट ऑपरेटर, कंपाउंड असाइनमेंट ऑपरेटर ( = , += , /= , आदि), बिल्ट-इन प्री-इन्क्रीमेंट और प्री-इंक्रीमेंट ( ++a , --b ), बिल्ट-इन पॉइंटर --b ऑपरेटर ( *p );
• इंडेक्स द्वारा निर्मित ऑपरेटर का उपयोग ( a[n] या n[a] ), जब ऑपरेंड में से एक एक लैवल्यू सरणी है;
• एक फ़ंक्शन या एक अतिभारित बयान को कॉल करना जो एक फ़ंक्शन के लिए एक संदर्भ संदर्भ देता है;
• स्ट्रिंग शाब्दिक जैसे "Hello, world!" ।

एक स्ट्रिंग शाब्दिक C ++ में अन्य सभी शाब्दिक से भिन्न होता है ठीक है कि यह एक लवल्यू (यद्यपि अपरिवर्तनीय) है। उदाहरण के लिए, आप इसका पता प्राप्त कर सकते हैं:

 auto* p = &”Hello, world!”; //   ,    

prvalue

विशेषताएं:

• सभी rvalue गुण (ऊपर देखें);
• बहुरूपी नहीं हो सकता: स्थिर और गतिशील अभिव्यक्ति प्रकार हमेशा मेल खाते हैं;
• अपूर्ण प्रकार का नहीं हो सकता ( शून्य प्रकार को छोड़कर, इस पर नीचे चर्चा की जाएगी);
• एक सार प्रकार नहीं हो सकता है या एक सार प्रकार के तत्वों की एक सरणी हो सकती है।

निम्नलिखित भाव प्रचलित श्रेणी के हैं:

• शाब्दिक (स्ट्रिंग को छोड़कर), उदाहरण के लिए 42 , true या nullptr ;
• एक फ़ंक्शन कॉल या एक अतिभारित ऑपरेटर जो एक गैर-संदर्भ ( str.substr(1, 2) , str1 + str2 , it++ ) या एक गैर-संदर्भ प्रकार के लिए रूपांतरण अभिव्यक्ति देता है (उदाहरण के लिए static_cast<double>(x) , std::string{} , (int)42 );
• अंतर्निहित पोस्ट-इन्क्रीमेंट और पोस्ट- b-- ( a++ , b-- ), बिल्ट-इन गणितीय कार्य ( a + b , a % b , a & b , a << b , etc.), बिल्ट-इन लॉजिकल ऑपरेशंस ( a && b , a || b !a , आदि), तुलना संचालन ( a < b , a == b , a >= b , आदि), पते ( &a ) लेने का अंतर्निहित ऑपरेशन;
• यह सूचक;
• लिस्टिंग आइटम;
• एटिपिकल टेम्पलेट पैरामीटर, यदि यह एक वर्ग नहीं है;
• लैम्ब्डा अभिव्यक्ति, उदाहरण के लिए [](int x){ return x * x; } [](int x){ return x * x; } ।

XValue

विशेषताएं:

• सभी rvalue गुण (ऊपर देखें);
• सभी चमक गुण (ऊपर देखें)।

Xvalue अभिव्यक्तियों के उदाहरण:

• एक फ़ंक्शन या बिल्ट-इन ऑपरेटर को कॉल करना जो एक प्रतिद्वंद्विता संदर्भ देता है, उदाहरण के लिए std :: move (x) ;

और वास्तव में, कॉलिंग std :: move () के परिणाम के लिए , आपको मेमोरी में एड्रेस नहीं मिल सकता है या इसके लिंक को इनिशियलाइज़ नहीं कर सकता है, लेकिन साथ ही, यह एक्सप्रेशन पॉलिमॉर्फिक हो सकता है:

 struct XA { virtual void f() { std::cout << "XA::f()\n"; } }; struct XB : public XA { virtual void f() { std::cout << "XB::f()\n"; } }; XA&& xa = XB(); auto* p = &std::move(xa); //  auto& r = std::move(xa); //  std::move(xa).f(); //  “XB::f()” 

• अनुक्रमणिका ( a[n] या n[a] ) द्वारा निर्मित ऑपरेटर के उपयोग के लिए जब ऑपरेंड में से एक एक प्रतिद्वंद्विता सरणी है।

कुछ विशेष मामले

कोमा संचालक

अंतर्निहित अल्पविराम ऑपरेटर के लिए, अभिव्यक्ति श्रेणी हमेशा दूसरे ऑपरेंड की अभिव्यक्ति श्रेणी से मेल खाती है।

 int n = 0; auto* pn = &(1, n); // lvalue auto& rn = (1, n); // lvalue 1, n = 2; // lvalue auto* pt = &(1, int(123)); // , rvalue auto& rt = (1, int(123)); // , rvalue 

व्यर्थ भाव

ऐसे कार्यों को कॉल करता है जो शून्य पर लौटते हैं, रूपांतरण के प्रकारों को शून्य करने के लिए टाइप करते हैं, और अपवादों को फेंकना प्रचलित भाव माना जाता है, लेकिन उनका उपयोग संदर्भों या कार्यों के तर्क के रूप में नहीं किया जा सकता है।

टर्नरी तुलना ऑपरेटर

अभिव्यक्ति की एक श्रेणी की परिभाषा a ? b : c - मामला अनौपचारिक है, यह सभी दूसरे और तीसरे तर्क ( b और c ) की श्रेणियों पर निर्भर करता है:

• यदि b या c टाइप शून्य हैं , तो पूरी अभिव्यक्ति की श्रेणी और प्रकार दूसरे तर्क की श्रेणी और प्रकार के अनुरूप हैं। यदि दोनों तर्क प्रकार के शून्य हैं , तो परिणाम प्रकार शून्य का प्रचलन है ;
• यदि b और c एक ही प्रकार के ग्लव्यू हैं, तो इसका परिणाम उसी प्रकार का ग्लव्यू है ;
• अन्य मामलों में, परिणाम प्रचलित है।

टर्नेरी ऑपरेटर के लिए, कई नियमों को परिभाषित किया गया है, जिसके अनुसार निहित रूपांतरण तर्क बी और सी पर लागू किए जा सकते हैं, लेकिन यह कुछ हद तक लेख के दायरे से परे है ; यदि आप रुचि रखते हैं, तो मैं मानक के कंडिशनर ऑपरेटर (एक्सप्रेंडकॉन्ड] अनुभाग का संदर्भ देने की सलाह देता हूं।

 int n = 1; int v = (1 > 2) ? throw 1 : n; // lvalue, .. throw   void,    n ((1 < 2) ? n : v) = 2; //  lvalue,  ,   ((1 < 2) ? n : int(123)) = 2; //   , ..    prvalue 

खेतों और वर्गों और संरचनाओं के तरीकों का संदर्भ

प्रपत्र am और p->m की अभिव्यक्तियों के लिए (यहां हम बिल्ट-इन ऑपरेटर के बारे में बात कर रहे हैं -> ), निम्नलिखित नियम लागू होते हैं:

• यदि m एक एन्यूमरेशन एलिमेंट या नॉन-स्टैटिक क्लास मेथड है, तो पूरे एक्सप्रेशन को प्रचलन माना जाता है (हालाँकि लिंक को इस तरह के एक्सप्रेशन से जोड़ा नहीं जा सकता है);
• यदि कोई अवलंबन है और m एक गैर-संदर्भ प्रकार का एक गैर-स्थिर क्षेत्र है, तो संपूर्ण अभिव्यक्ति xvalative श्रेणी से संबंधित है;
• अन्यथा यह एक अंतराल है ।

कक्षा सदस्यों ( a.*mp और p->*mp ) के संकेत के लिए, नियम समान हैं:

• यदि mp एक वर्ग विधि का एक संकेतक है, तो संपूर्ण अभिव्यक्ति को प्रचलन माना जाता है ;
• यदि कोई रव्यू है , और mp एक डेटा क्षेत्र के लिए एक संकेतक है, तो पूरी अभिव्यक्ति xvalue को संदर्भित करती है ;
• अन्यथा यह एक अंतराल है ।

बिट क्षेत्र

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

बिट-फ़ील्ड [class.bit]
यदि प्रकार const T & के संदर्भ के लिए इनिशलाइज़र एक लैवल्यू है जो बिट-फ़ील्ड को संदर्भित करता है, तो संदर्भ बिट-फ़ील्ड का मान रखने के लिए एक अस्थायी इनिशियलाइज़्ड के लिए बाध्य है; संदर्भ सीधे बिट-फ़ील्ड के लिए बाध्य नहीं है।

 struct BF { int f:3; }; BF b; bf = 1; // OK auto* pb = &b.f; //  auto& rb = bf; //  

एक निष्कर्ष के बजाय

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