दिलचस्प पोस्ट
क्या कुछ टेक्स्ट वाले तत्वों के लिए कोई सीएसएस चयनकर्ता है? PyCharm वैध कोड के लिए अनसुलझे संदर्भ त्रुटि दिखाता है टॉमकेट में अनुरोध एन्कोडिंग कैसे सेट करें? जावास्क्रिप्ट के साथ ब्राउज़र में एंड्रॉइड फोन के रोटेशन का पता लगाएं <Input type = 'button' /> और <input type = 'submit' /> के बीच का अंतर पोस्टग्रेस्क्ल GROUP_CONCAT समकक्ष? क्या सबसे अच्छा / सामान्य शांत यूआरएल क्रिया और क्रियाएं हैं? गिट रेपो से कई फ़ाइलों को हटाने से पहले ही डिस्क से हटा दिया गया है जब मुख्य () निकल जाता है तो अलग थ्रेड का क्या होता है? C ++ में निजी विधि को कॉल करना तिथि के अनुसार git चेकआउट प्रोल मैल प्रोपर्टी जो कि तत्वों को सूचीबद्ध करने के लिए वर्दी लागू करता है Android साझा वरीयताएँ उदाहरण PHP – और / या कीवर्ड प्लेसहोल्डर के लिए पीडीओ वैध वर्ण

कैसे एक गैर-कॉन्फ्रेंस संदर्भ एक अस्थायी ऑब्जेक्ट से बाध्य नहीं हो सकता है?

अस्थायी ऑब्जेक्ट के लिए गैर-कॉन्स्ट संदर्भ प्राप्त करने की अनुमति क्यों नहीं है, जो getx() रिटर्न का काम करता है? जाहिर है, यह सी ++ मानक द्वारा निषिद्ध है, लेकिन मैं इस तरह के प्रतिबंध के उद्देश्य में रूचि हूं, मानक के संदर्भ में नहीं

 struct X { X& ref() { return *this; } }; X getx() { return X();} void g(X & x) {} int f() { const X& x = getx(); // OK X& x = getx(); // error X& x = getx().ref(); // OK g(getx()); //error g(getx().ref()); //OK return 0; } 
  1. यह स्पष्ट है कि ऑब्जेक्ट के जीवनकाल का कारण नहीं हो सकता, क्योंकि किसी ऑब्जेक्ट का लगातार संदर्भ C ++ मानक द्वारा निषिद्ध नहीं है
  2. यह स्पष्ट है कि अस्थायी ऑब्जेक्ट ऊपर दिए गए नमूने में स्थिर नहीं है, क्योंकि गैर-निरंतर फ़ंक्शन को कॉल की अनुमति है। उदाहरण के लिए, ref() अस्थायी ऑब्जेक्ट को संशोधित कर सकता है।
  3. इसके अतिरिक्त, ref() आपको कंपाइलर को बेवकूफ बनाने और इस अस्थायी ऑब्जेक्ट के लिए एक लिंक प्राप्त करने की अनुमति देता है और यह हमारी समस्या का समाधान करता है।

के अतिरिक्त:

वे कहते हैं "const संदर्भ के लिए एक अस्थायी वस्तु निर्दिष्ट करना इस वस्तु के जीवनकाल को बढ़ाता है" और "गैर-कॉन्स्ट संदर्भों के बारे में कुछ नहीं कहा गया है"। मेरा अतिरिक्त प्रश्न क्या निम्नलिखित कार्य अस्थायी ऑब्जेक्ट के जीवनकाल को बढ़ाता है?

 X& x = getx().ref(); // OK 

वेब के समाधान से एकत्रित समाधान "कैसे एक गैर-कॉन्फ्रेंस संदर्भ एक अस्थायी ऑब्जेक्ट से बाध्य नहीं हो सकता है?"

इस दृश्य सी ++ ब्लॉग आलेख से rvalue संदर्भों के बारे में :

… सी ++ आप गलती से अस्थायी रूप से संशोधित नहीं करना चाहते हैं, लेकिन सीधे रूप से संशोधित रवैये पर एक गैर-कॉन्स्ट सदस्य समारोह को बुलाकर स्पष्ट है, इसलिए इसकी अनुमति है …

असल में, आपको अस्थायी वस्तुएं संशोधित करने का प्रयास नहीं करना चाहिए क्योंकि वे अस्थायी वस्तुएं हैं और अब किसी भी क्षण मर जाएंगे। आपको गैर- const विधियों को कॉल करने की अनुमति दी जाने वाली वजह यह है कि, ठीक है, जब तक आप जानते हैं कि आप क्या कर रहे हैं और आप इसके बारे में स्पष्ट हैं (जैसे reinterpret_cast का प्रयोग करते हैं) तब तक कुछ "बेवकूफ" चीजों का स्वागत करते हैं। लेकिन अगर आप अस्थायी रूप से गैर-कॉन्स्ट संदर्भ में बाँधते हैं, तो आप वस्तु का हेरफेर गायब होने के लिए "हमेशा" के आसपास गुजर सकते हैं, क्योंकि जिस तरह से आप पूरी तरह से भूल गए थे वह कहीं अस्थायी है।

अगर मैं तुम थे, तो मैं अपने कार्यों के डिजाइन को फिर से सोचूंगा। जी () क्यों स्वीकार है संदर्भ, यह पैरामीटर को संशोधित करता है? यदि नहीं, तो इसे संदर्भ बनाएं, यदि हां, तो आप इसे अस्थायी रूप से पारित करने का प्रयास क्यों करते हैं, क्या आप परवाह नहीं है कि आप अस्थायी रूप से संशोधित हैं? क्यों getx () वैसे भी अस्थायी लौट रहा है? यदि आप हमारे साथ अपने वास्तविक परिदृश्य और आप को पूरा करने की कोशिश कर रहे हैं, तो आप इसे कैसे करें पर कुछ अच्छे सुझाव प्राप्त कर सकते हैं।

भाषा के खिलाफ जा रहे हैं और कम्पाइलर को बेवकूफ बनाना शायद ही कभी समस्याओं को हल करता है – आमतौर पर यह समस्याएं पैदा करता है


संपादित करें: टिप्पणी में सवालों को संबोधित: 1) X& x = getx().ref(); // OK when will x die? X& x = getx().ref(); // OK when will x die? – मुझे नहीं पता है और मुझे परवाह नहीं है, क्योंकि यह वास्तव में "भाषा के विरुद्ध चलने" का मतलब है। भाषा कहती है, "अस्थायी बयान के अंत में मर जाते हैं, जब तक कि वे संदर्भ संविधान के लिए बाध्य नहीं हों, जिस मामले में वे मर जाते हैं जब संदर्भ गुंजाइश से बाहर हो जाता है"। उस नियम को लागू करने से ऐसा लगता है कि एक्स अगले वक्त की शुरुआत में पहले से ही मर चुका है, क्योंकि यह संदर्भ संदर्भ के लिए बाध्य नहीं है (संकलक को नहीं पता है कि क्या रिफ () रिटर्न)। यह सिर्फ एक अनुमान है लेकिन

2) मैंने इस उद्देश्य को स्पष्ट रूप से बताया है: आपको अस्थायी रूप से संशोधित करने की अनुमति नहीं है, क्योंकि यह सिर्फ समझ में नहीं आता है (सी ++ 0x रैवल्यू संदर्भों की उपेक्षा करना) प्रश्न "तो मुझे गैर-कॉन्स्ट सदस्य क्यों कॉल करने की अनुमति है?" एक अच्छा है, लेकिन मेरे पास पहले से ही ऊपर बताए गए एक से बेहतर जवाब नहीं है

3) ठीक है, अगर मैं एक्स के बारे में x के बारे में सही हूँ X& x = getx().ref(); बयान के अंत में मर रहा है, समस्याओं स्पष्ट हैं

वैसे भी, आपके प्रश्न और टिप्पणियों के आधार पर, मुझे नहीं लगता कि ये अतिरिक्त जवाब भी आपको संतुष्ट करेंगे। यह एक अंतिम प्रयास / सारांश है: सी ++ समिति ने फैसला किया कि यह अस्थायी रूपों को संशोधित करने का मतलब नहीं है, इसलिए, उन्होंने गैर-कॉन्स्ट संदर्भों के लिए बाध्य करने की अनुमति नहीं दी है। हो सकता है कि कुछ कंपाइलर कार्यान्वयन या ऐतिहासिक मुद्दों को भी शामिल किया गया, मुझे नहीं पता। फिर, कुछ विशिष्ट मामले उभरे, और यह निर्णय लिया गया कि सभी बाधाओं के खिलाफ, वे अभी भी गैर-कॉन्स्ट विधि कॉल करने के माध्यम से सीधे संशोधन की अनुमति देगा। लेकिन यह एक अपवाद है – आम तौर पर आपको अस्थायी रूप से संशोधित करने की अनुमति नहीं है हां, सी ++ अक्सर वह अजीब होता है

आपके कोड में getx() एक अस्थायी ऑब्जेक्ट, एक तथाकथित "rvalue" देता है आप रैवल्यू को चीजों (उर्फ चर) में कॉपी कर सकते हैं या उन्हें सन्दर्भ के संदर्भ में बाँध सकते हैं (जो संदर्भ के जीवन के अंत तक अपने जीवन-काल का विस्तार करेंगे)। आप गैर-कॉन्स्ट संदर्भों के लिए रैवल्यू को बाध्य नहीं कर सकते।

यह एक जानबूझकर डिजाइन निर्णय था ताकि उपयोगकर्ताओं को गलती से एक ऐसी वस्तु को संशोधित किया जा सके जो अभिव्यक्ति के अंत में मरने वाला है:

 g(getx()); // g() would modify an object without anyone being able to observe 

यदि आप ऐसा करना चाहते हैं, तो आपको या तो स्थानीय प्रति या ऑब्जेक्ट को पहले बनाना होगा या इसे किसी संदर्भ संदर्भ में बाँध देना होगा:

 X x1 = getx(); const X& x2 = getx(); // extend lifetime of temporary to lifetime of const reference g(x1); // fine g(x2); // can't bind a const reference to a non-const reference 

ध्यान दें कि अगले C ++ मानक में रैवल्यू संदर्भ शामिल होंगे। आप संदर्भों के रूप में जानते हैं, इसलिए "लावल्यू संदर्भ" कहा जा रहा है। आपको रैवल्यू को संदर्भों में बाध्य करने की अनुमति दी जाएगी और आप "रैवल्यू-नेस" पर कार्यों को ओवरलोड कर सकते हैं:

 void g(X&); // #1, takes an ordinary (lvalue) reference void g(X&&); // #2, takes an rvalue reference X x; g(x); // calls #1 g(getx()); // calls #2 g(X()); // calls #2, too 

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

 class X { X(X&& rhs) : pimpl( rhs.pimpl ) // steal rhs' data... { rhs.pimpl = NULL; // ...and leave it empty, but deconstructible } data* pimpl; // you would use a smart ptr, of course }; X x(getx()); // x will steal the rvalue's data, leaving the temporary object empty 

आप क्या दिखा रहे हैं कि ऑपरेटर चेनिंग की अनुमति है

  X& x = getx().ref(); // OK 

अभिव्यक्ति है 'getx ()। रेफरी ();' और इसे 'एक्स' के लिए असाइनमेंट से पहले पूरा करने के लिए निष्पादित किया जाता है

ध्यान दें कि Getx () एक संदर्भ नहीं लौटाता है, लेकिन स्थानीय संदर्भ में पूरी तरह से बनाई गई वस्तु है। वस्तु अस्थायी है लेकिन यह const नहीं है , इस प्रकार आप मूल्य की गणना करने के लिए अन्य विधियों को कॉल करने या अन्य दुष्प्रभावों को उत्पन्न करने की इजाजत दे सकते हैं।

 // It would allow things like this. getPipeline().procInstr(1).procInstr(2).procInstr(3); // or more commonly std::cout << getManiplator() << 5; 

इस का एक बेहतर उदाहरण के लिए इस उत्तर के अंत में देखो

आप एक संदर्भ में एक अस्थायी रूप से बाध्य नहीं कर सकते क्योंकि ऐसा करने से किसी वस्तु के संदर्भ उत्पन्न हो जाएगा जिसे अभिव्यक्ति के अंत में नष्ट कर दिया जाएगा, जिससे आपको एक झूठ संदर्भ (जो कि गंदगी और मानक को गंदे नहीं दिखता है) के साथ छोड़ दिया जाता है।

रेफरी () से लौटा जाने वाला मान एक वैध संदर्भ है, लेकिन विधि उस वस्तु के जीवन काल पर कोई ध्यान नहीं देता है, क्योंकि वह वापस लौट रहा है (क्योंकि उस संदर्भ में इसकी जानकारी नहीं हो सकती)। आपने मूल रूप से बस के बराबर किया है:

 x& = const_cast<x&>(getX()); 

अस्थायी ऑब्जेक्ट के लिए एक कॉन्फ्रेंस संदर्भ के साथ यह करने के लिए ठीक है कि यह मानक संदर्भ के जीवन काल में अस्थायी जीवन काल तक फैली है ताकि अस्थायी वस्तुओं का जीवनकाल बयान के अंत से आगे बढ़ाया जा सके।

तो केवल एकमात्र सवाल यह है कि क्या मानक अस्थायी लोगों को बयान के अंत से परे वस्तु के जीवन का विस्तार करने की अनुमति नहीं देता है?

मेरा मानना ​​है कि ऐसा इसलिए है कि ऐसा करने से संकलक बहुत अस्थायी वस्तुओं के लिए सही हो सके यह अस्थायी लोगों के लिए संदर्भ संदर्भों के लिए किया गया था क्योंकि इसका उपयोग सीमित था और इस प्रकार आपको कुछ उपयोगी काम करने के लिए वस्तु की प्रतिलिपि बनाने के लिए मजबूर किया गया था लेकिन कुछ सीमित कार्यक्षमता प्रदान करता है

इस स्थिति के बारे में सोचो:

 int getI() { return 5;} int x& = getI(); x++; // Note x is an alias to a variable. What variable are you updating. 

इस अस्थायी वस्तु की उम्र बढ़ने से बहुत भ्रमित हो रहा है।
जबकि निम्नलिखित:

 int const& y = getI(); 

आपको वह कोड देगा जो इसका उपयोग करने और समझने के लिए सहज है।

यदि आप मान को संशोधित करना चाहते हैं तो आपको वैरिएबल को मान वापस करना चाहिए। यदि आप कार्य से वापस ऑब्जेक्ट कॉपी करने की लागत से बचने की कोशिश कर रहे हैं (जैसा कि ऐसा लगता है कि ऑब्जेक्ट प्रतिलिपि बनाई गई है (तकनीकी रूप से यह है)। फिर परेशान मत करो 'रिटर्न वैल्यू ऑप्टिमाइज़ेशन' पर कंपाइलर बहुत अच्छा है

मुख्य मुद्दा ये है कि

 g(getx()); //error 

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

 const X& x = getx(); // OK 

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

हालांकि यह करना संभव नहीं है

 X& x = getx(); // error 

g(getx()) बिना वैध g(getx()) मान्य है, जो भाषा डिजाइनर पहली जगह से बचने की कोशिश कर रहे थे।

 g(getx().ref()); //OK 

वैध है क्योंकि विधियों को केवल इस की अवस्था के बारे में पता है, उन्हें नहीं पता कि क्या उन्हें लार्वेल या रेंवेल पर कहा जाता है

हमेशा की तरह सी ++ में, आपके पास इस नियम के लिए एक वैकल्पिक हल है लेकिन आपको संकलक को सिग्नल करना होगा कि आप जानते हैं कि आप स्पष्ट रूप से क्या कर रहे हैं:

 g(const_cast<x&>(getX())); 

मूल प्रश्न की तरह लगता है कि इसे क्यों अनुमति नहीं दी गई है स्पष्ट रूप से उत्तर दिया गया है: "क्योंकि यह सबसे अधिक संभावना है"।

एफडब्ल्यूआईडब्ल्यू, मैंने सोचा था कि मैं यह कैसे दिखा सकता हूं कि यह कैसे किया जा सकता है, भले ही मुझे नहीं लगता कि यह एक अच्छी तकनीक है

जिस कारण से मैं कभी-कभी किसी गैर-कॉन्स्ट संदर्भ लेने वाली किसी विधि को अस्थायी रूप से पारित करना चाहता हूं, वह जानबूझकर वापस लौटाए जाने वाले मूल्य को फेंकने का है, जिसे कॉलिंग विधि की परवाह नहीं है। कुछ इस तरह:

 // Assuming: void Person::GetNameAndAddr(std::string &name, std::string &addr); string name; person.GetNameAndAddr(name, string()); // don't care about addr 

जैसा कि पिछले उत्तर में बताया गया है, जो संकलन नहीं करता है लेकिन यह सही तरीके से संकलित और काम करता है (मेरे कंपाइलर के साथ):

 person.GetNameAndAddr(name, const_cast<string &>(static_cast<const string &>(string()))); 

यह सिर्फ दिखाता है कि आप कम्पाइलर से झूठ बोलने के लिए कास्टिंग का उपयोग कर सकते हैं। जाहिर है, यह एक अप्रयुक्त स्वत: चर घोषित करने और पास करने के लिए बहुत क्लीनर होगा:

 string name; string unused; person.GetNameAndAddr(name, unused); // don't care about addr 

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

 string name; { string unused; person.GetNameAndAddr(name, unused); // don't care about addr } 

– क्रिस

सी ++ अकसर किये गए सवाल ( बोल्डफाइंग खान) में क्यों चर्चा की गई है:

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

 void incr(int& a) { ++a; } int i = 0; incr(i); // i becomes 1 incr(0); // error: 0 is not an lvalue 

अगर उस इंक (0) को कुछ अस्थायी रूप से अनुमति दी गई थी जिसे कभी भी देखा नहीं गया था या बढ़ जाएगा या बहुत ज्यादा – 0 का मान 1 हो जाएगा। बाद वाला कोई मूर्खतापूर्ण नहीं है, लेकिन वास्तव में एक बग था, जैसे कि फोर्ट्रान कंपलर के प्रारंभ में एकमात्र स्मृति स्थान को मान 0 रखने के लिए

आप कभी क्यों X& x = getx(); ? बस X x = getx(); और आरवीओ पर भरोसा करते हैं

बुरे कामकाज में 'अस्थिर' कीवर्ड शामिल है। दरअसल बुराई को पाठक के लिए एक अभ्यास के रूप में छोड़ दिया गया है। या यहां देखें: http://www.ddj.com/cpp/184403758

उत्कृष्ट प्रश्न, और यहां एक अधिक संक्षिप्त उत्तर पर मेरा प्रयास है (क्योंकि बहुत उपयोगी जानकारी टिप्पणी में है और शोर में खोदने के लिए कठिन है।)

किसी भी अस्थायी रूप से सीधे संदर्भित किसी भी संदर्भ को अपने जीवन का विस्तार होगा [12.2.5] दूसरी ओर, एक अन्य संदर्भ के साथ शुरू किया गया एक संदर्भ नहीं होगा (भले ही यह अंततः एक ही अस्थायी है) यह समझ में आता है (संकलक को यह नहीं पता कि अंत में इसका संदर्भ क्या है)

लेकिन यह पूरी कल्पना बेहद भ्रामक है। जैसे const X &x = X(); x संदर्भ के रूप में लंबे समय तक अस्थायी बना देगा, लेकिन const X &x = X().ref(); नहीं होगा (कौन जानता है कि वास्तव में क्या लौटा) बाद के मामले में, X लिए डिस्ट्रक्टर को इस लाइन के अंत में कहा जाता है (यह एक गैर-तुच्छ विध्वंसक के साथ अवलोकन किया गया है।)

तो ऐसा लगता है कि आम तौर पर भ्रमित और खतरनाक (वस्तु के जन्म के समय के नियमों को क्यों जटिल बनाते हैं?), लेकिन संभवतया const संदर्भों के लिए कम से कम एक आवश्यकता थी, इसलिए मानक उनके लिए यह व्यवहार सेट करता है

[ एसबीआई टिप्पणी से]: ध्यान दें कि तथ्य यह है कि इसे एक संदर्भ संदर्भ में बाइंडिंग एक अस्थायी जीवन काल बढ़ाता है एक अपवाद है जिसे जानबूझकर जोड़ दिया गया है (मैन्युअल अनुकूलन की अनुमति देने के लिए टीटीबीओएमके)। गैर-कॉन्फ्रेंस संदर्भों के लिए कोई अपवाद जोड़ा नहीं गया था, क्योंकि गैर-कॉन्स्ट संदर्भ में एक अस्थायी बंधन को सबसे अधिक संभावना एक प्रोग्रामर त्रुटि के रूप में देखा गया था

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

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

"यह स्पष्ट है कि अस्थायी ऑब्जेक्ट ऊपर दिए गए नमूने में स्थिर नहीं है, क्योंकि गैर-निरंतर कार्यों की कॉल की अनुमति है। उदाहरण के लिए, रेफरी () अस्थायी ऑब्जेक्ट को संशोधित कर सकता है।"

आपके उदाहरण में getX () एक कंसोर्ट एक्स वापस नहीं लौटाता है, जिससे आप रेफरी () को उसी तरीके से फोन कर सकते हैं जैसा कि आप एक्स () को कॉल कर सकते हैं। Ref () आप एक गैर कॉन्स्ट्र रेफ्रेंस लौट रहे हैं और इसलिए गैर कॉन्स्ट विधियां कॉल कर सकते हैं, जो आप नहीं कर सकते हैं वह एक गैर कॉन्स्ट्र संदर्भ के लिए रेफरी प्रदान करता है।

SadSidos टिप्पणी के साथ यह आपके तीन बिंदुओं को गलत बनाता है।

मेरे पास एक ऐसा परिदृश्य है जिसे मैं साझा करना चाहूंगा, जहां मैं चाहता हूं कि मैं एलेक्सी क्या कह रहा हूं। माया सी ++ प्लगइन में, मुझे एक नोड विशेषता में मान प्राप्त करने के लिए निम्नलिखित शैनैनिगन करना होगा:

 MFnDoubleArrayData myArrayData; MObject myArrayObj = myArrayData.create(myArray); MPlug myPlug = myNode.findPlug(attributeName); myPlug.setValue(myArrayObj); 

यह लिखना कठिन है, इसलिए मैंने निम्नलिखित सहायक कार्यों को लिखा:

 MPlug operator | (MFnDependencyNode& node, MObject& attribute){ MStatus status; MPlug returnValue = node.findPlug(attribute, &status); return returnValue; } void operator << (MPlug& plug, MDoubleArray& doubleArray){ MStatus status; MFnDoubleArrayData doubleArrayData; MObject doubleArrayObject = doubleArrayData.create(doubleArray, &status); status = plug.setValue(doubleArrayObject); } 

और अब मैं पोस्ट की शुरुआत से कोड लिख सकता हूं:

 (myNode | attributeName) << myArray; 

समस्या यह है कि वह विज़ुअल सी ++ के बाहर संकलित नहीं करता है, क्योंकि वह अस्थायी चर को बाध्य करने की कोशिश कर रहा है | ऑपरेटर << ऑपरेटर के एमपी लेग संदर्भ के लिए मैं इसे एक संदर्भ मानना ​​चाहूंगा क्योंकि इस कोड को कई बार कहा जाता है और मैं नहीं चाहता कि MPlug को इतना कॉपी किया गया। मुझे केवल दूसरे फ़ंक्शन के अंत तक रहने के लिए अस्थायी ऑब्जेक्ट की आवश्यकता है।

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

धन्यवाद।