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




pointers vector (3)

मुझे यकीन नहीं है कि 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 का उपयोग करता हूं।


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.

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

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

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


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