c++ Int पॉइंटर्स के कॉन्स्ट वेक्टर में dereferenced तत्व mutable क्यों है?




pointers vector (4)

Int पॉइंटर्स के कॉन्स्ट वेक्टर में dereferenced तत्व mutable क्यों है?

const vector<int *> , तत्व गैर- const , यानी int * const लिए const पॉइंटर होगा, ताकि आप पॉइंटर द्वारा इंगित ऑब्जेक्ट को संशोधित कर सकें, लेकिन पॉइंटर स्वयं ही नहीं।

ऑपरेटर प्राथमिकता के अनुसार, पोस्टफिक्स वृद्धि ऑपरेटर operator* तुलना में अधिक प्राथमिकता है, इसलिए *(w[0]) ++; के बराबर है

* ((w[0]) ++);

पॉइंटर पर वृद्धि पहले किया जाता है, फिर यह विफल हो जाता है। w[0] = &y; सूचक को संशोधित करने की भी कोशिश कर रहा है, इसलिए यह भी विफल रहता है।

दूसरी तरफ, (*w[0]) ++; (यानी पॉइंट पर वृद्धि) ठीक होगा। और निम्नलिखित कथन भी ठीक हैं, क्योंकि वे पॉइंटर द्वारा इंगित वस्तुओं को संशोधित कर रहे हैं, पॉइंटर्स नहीं।

*(w[0]) += 3; //passed.
*(w[0]) = 20; //passed.

https://code.i-harness.com

मुझे यकीन नहीं है कि const vector<int *> का सही अर्थ है इसलिए मैंने एक विचार प्राप्त करने के लिए नीचे दिए गए कोड को संकलित किया लेकिन अब और अधिक उलझन में हूं।

vector<int *> v;
int x = 1, y = 2;
v.push_back(&x);
v.push_back(&y);

const vector<int *> w = v;
w[0] = &y;   //failed. Element is a constant pointer?
*(w[0]) ++;  //failed. Element pointer references to constant value?

अगर मैं यहां रुक गया था, तो मैंने माना होगा कि const vector<int *> const int * const का एक वेक्टर है, लेकिन फिर मैंने निम्नलिखित कोशिश की जो स्पष्ट रूप से उस धारणा का खंडन करते थे।

*(w[0]) += 3; //passed. Value not constant?
*(w[0]) = 20; //passed. Why...

अब *(w[0]) मेरे लिए अज्ञात कारण के लिए स्पष्ट रूप से ++ और += और असाइनमेंट का व्यवहार करता है। मैंने खुद को आश्वस्त किया कि const vector केवल vector वर्ग की निरंतर वस्तु घोषित करता है और उपर्युक्त परिणाम vector वर्ग के ऑपरेटर ओवरलोडिंग के वास्तविक कार्यान्वयन पर निर्भर हो सकते हैं। लेकिन मैं इसके चारों ओर अपने सिर लपेट नहीं सकता। क्या कोई समझाने में मदद कर सकता है, कृपया?

यदि यह प्रासंगिक है, तो मैक पर g ++ 4.2 का उपयोग करता हूं।


यह ऑपरेटर प्राथमिकता का मामला है

जब आप *(w[0]) ++ तो आप सूचक को संशोधित करने का प्रयास करते हैं।

जब आप *(w[0]) += 3 तो आप पॉइंटर द्वारा इंगित डेटा को संशोधित करते हैं।


const vector<T> आपको T const & तत्वों ( यानी const T & ) के रूप में अपने तत्वों तक पहुंचने देता है। इस मामले में, T int * , इसलिए यह int * const & , int * const & एक सूचक का संदर्भ है जो एक int को इंगित करता है। सूचक स्थिर है, लेकिन int नहीं है।

वेक्टर के प्रकार को vector<int const *> ( यानी vector<const int*> ) होने की आवश्यकता होती है, इस मामले में तत्वों को int const * const & माध्यम से एक्सेस किया जाएगा।

नीचे की रेखा, स्थिरता टेम्पलेट्स के साथ संक्रमणीय है लेकिन पॉइंटर्स के साथ नहीं। और यदि आप टेम्पलेट्स में पॉइंटर्स डालते हैं, तो आप दोनों व्यवहारों का थोड़ा सा हिस्सा प्राप्त करते हैं।


w एक const vector<int *>const क्वालीफायर वेक्टर पर लागू होता है। इसलिए, संबंधित const सदस्य फ़ंक्शन operator[] लिए उपयोग किया जाएगा operator[] :

const_reference operator[]( size_type pos ) const;

चूंकि वेक्टर को समेकित किया गया है और इसमें टाइप int * (और const int * ) के तत्व शामिल हैं, अभिव्यक्ति का प्रकार w[0] int * const& ( const int *& बजाय) है। यही है, यह एक int लिए निरंतर सूचक का संदर्भ है और निरंतर int लिए सूचक का संदर्भ नहीं है: स्थिरता को पॉइंटर पर ही लागू किया जाता है, न कि डेटा को इंगित किया जा रहा है।

*(w[0]) += 3 करके आप वेक्टर रिटर्न (जो const ) सूचक के मान को संशोधित नहीं कर रहे हैं, लेकिन यह सूचक जिस बिंदु को इंगित कर रहा है । चूंकि यह सूचक प्रकार int * const (और const int * ) है, इसलिए आप जो भी इंगित कर रहे हैं उसे संशोधित कर सकते हैं, इसलिए यह काम करता है। हालांकि, w[0] = &y निरंतर सूचक पर असाइनमेंट कर रहा है, इसलिए यह संकलित नहीं होता है।







operator-precedence