Int const * p और const int * p के बीच अंतर क्या है?


जवाब 1:

नमस्ते,

प्रश्न में दो चीजें शामिल हैं कॉन्स्टेंट और पॉइंटर।

और यह भी दो ऑपरेटरों कि हम सूचक और * में मुठभेड़ कर रहे हैं। & पॉइंटर को वेरिएबल के पते को असाइन करने के लिए है और * का उपयोग उस स्थान के मूल्य को संदर्भित करने के लिए किया जाता है जहां पॉइंटर इंगित करता है।

अब सवाल आ रहा है,

const int * p एक स्थिर चर का सूचक है और जैसा कि हम सभी जानते हैं कि हम एक स्थिरांक का मान नहीं बदल सकते हैं इसलिए निम्न ऑपरेशन अमान्य है और एक त्रुटि देता है।

* पी = 3; // अमान्य यहां हम एक स्थिर चर को संशोधित करने का प्रयास कर रहे हैं।

लेकिन p = & i; // वैध है मैं कोई भी चर हो सकता है

वहाँ एक स्थिर करने के लिए सूचक निर्दिष्ट करने के लिए एक और तरीका है यानी

int const * p1; // पॉइंटर टू कंटिन्यू इंट

एक और प्रकार की घोषणा है जिसे हम देखते हैं अर्थात् int * const p यह एक स्थिर सूचक के रूप में जाना जाता है इसका मतलब यह है कि यह जिस बिंदु को इंगित करता है उसे बदला नहीं जा सकता है जैसे कि संचालन

* पी = 3; // वैरिएबल के मान के रूप में मान्य माना जाता है।

लेकिन पी = और मैं; // अमान्य माना जाता है क्योंकि यह निरंतर के मूल्य को बदलने का प्रयास करता है।

निरंतर पॉइंटर को स्थिर घोषित करना भी संभव है। उस स्थिति में न तो पॉइंटर का मूल्य और न ही आधार डेटा आइटम का मूल्य बदला जा सकता है। वाक्य रचना है

const int * कॉन्स्ट पी;

यहाँ वाक्यविन्यास को याद करने का एक तरीका है, यानी CONSTANT POINTER में, "const" हमेशा * के बाद आता है।

यदि आप इस यात्रा geeksforgeeks पर और अधिक पढ़ना चाहते हैं और C में कांस्ट क्वालिफायर की खोज करते हैं, तो यह प्रोग्राम है जो अधिक व्याख्या करेगा।

आशा है कि यह कुछ संदेह को स्पष्ट करेगा।


जवाब 2:

int const * p => p एक पूर्णांक चर के लिए एक स्थिर सूचक है और जिसमें p द्वारा इंगित किया गया पता स्थिर होगा (बदला नहीं जा सकता) और उस पते का मान बदला जा सकता है

const int * p => p एक निरंतर पूर्णांक चर का सूचक है और जिसमें p द्वारा इंगित पते का मूल्य स्थिर होगा और p द्वारा इंगित किया गया पता बदला जा सकता है


जवाब 3:
कब्ज और संकेत:

एक पॉइंटर से कंटीन्यू और ए के बीच अंतर करना महत्वपूर्ण है
एक चर के लिए निरंतर सूचक।

यहाँ एक पॉइंटर को स्थिरांक पर रखा गया है:

  const int * p;

निम्न कथन अवैध है, क्योंकि यह परिवर्तन का प्रयास करता है
एक स्थिर मूल्य:

  * पी = 3;

लेकिन यह एक कानूनी है, क्योंकि सूचक स्वयं एक स्थिर नहीं है:

  p = & x;

दूसरी ओर, यह घोषणा एक चर के लिए एक निरंतर सूचक दिखाती है।

  int * const p;

उस स्थिति में, निम्न कथन कानूनी है, क्योंकि परिवर्तनशील को बदला जा सकता है:

  * पी = 3;

लेकिन यह एक नहीं है, क्योंकि यह एक स्थिर मूल्य को बदलने का प्रयास करता है।

  p = & x;

निरंतर पॉइंटर को स्थिर घोषित करना संभव है। उस में
मामले में न तो पॉइंटर का मूल्य और न ही आधार डेटा का मूल्य
आइटम बदला जा सकता है:

  const int * कॉन्स्ट पी;


यहाँ वाक्य विन्यास को याद करने का एक तरीका है (बज़्ने स्ट्रॉस्ट्रुप से):

ध्यान दें कि कॉन्स्ट पॉइंटर्स में, "कॉन्स्ट" हमेशा "*" के बाद आता है। के लिये
उदाहरण:

  int * const p1 = q; // निरंतर चर के लिए सूचक
  int const * P2 = q; // पॉइंटर टू कंटिन्यू इंट
  const int * p3 = q; // पॉइंटर टू कंटिन्यू इंट

दूसरा तरीका यह है कि '*' के बारे में सबसे बड़ा वामपंथी कब्जा करने के बारे में सोचें
इकाई है कि यह कर सकते हैं। 'कांस्ट' सबसे छोटी इकाई को छोड़ता है, जो बाएं या दाएं,
वह कर सकता है। तो ऊपर दिए गए उदाहरणों के बारे में सोचें:

  (int *) const p1 = q; // निरंतर चर के लिए सूचक
  (int const) * पी 2 = क्यू; // पॉइंटर टू कंटिन्यू इंट
  (const int) * p3 = q; // पॉइंटर टू कंटिन्यू इंट

दूसरे शब्दों में, चर से पहले क्वालीफायर तुरंत होता है
परिभाषा का पहला शब्द।


जवाब 4:
कब्ज और संकेत:

एक पॉइंटर से कंटीन्यू और ए के बीच अंतर करना महत्वपूर्ण है
एक चर के लिए निरंतर सूचक।

यहाँ एक पॉइंटर को स्थिरांक पर रखा गया है:

  const int * p;

निम्न कथन अवैध है, क्योंकि यह परिवर्तन का प्रयास करता है
एक स्थिर मूल्य:

  * पी = 3;

लेकिन यह एक कानूनी है, क्योंकि सूचक स्वयं एक स्थिर नहीं है:

  p = & x;

दूसरी ओर, यह घोषणा एक चर के लिए एक निरंतर सूचक दिखाती है।

  int * const p;

उस स्थिति में, निम्न कथन कानूनी है, क्योंकि परिवर्तनशील को बदला जा सकता है:

  * पी = 3;

लेकिन यह एक नहीं है, क्योंकि यह एक स्थिर मूल्य को बदलने का प्रयास करता है।

  p = & x;

निरंतर पॉइंटर को स्थिर घोषित करना संभव है। उस में
मामले में न तो पॉइंटर का मूल्य और न ही आधार डेटा का मूल्य
आइटम बदला जा सकता है:

  const int * कॉन्स्ट पी;


यहाँ वाक्य विन्यास को याद करने का एक तरीका है (बज़्ने स्ट्रॉस्ट्रुप से):

ध्यान दें कि कॉन्स्ट पॉइंटर्स में, "कॉन्स्ट" हमेशा "*" के बाद आता है। के लिये
उदाहरण:

  int * const p1 = q; // निरंतर चर के लिए सूचक
  int const * P2 = q; // पॉइंटर टू कंटिन्यू इंट
  const int * p3 = q; // पॉइंटर टू कंटिन्यू इंट

दूसरा तरीका यह है कि '*' के बारे में सबसे बड़ा वामपंथी कब्जा करने के बारे में सोचें
इकाई है कि यह कर सकते हैं। 'कांस्ट' सबसे छोटी इकाई को छोड़ता है, जो बाएं या दाएं,
वह कर सकता है। तो ऊपर दिए गए उदाहरणों के बारे में सोचें:

  (int *) const p1 = q; // निरंतर चर के लिए सूचक
  (int const) * पी 2 = क्यू; // पॉइंटर टू कंटिन्यू इंट
  (const int) * p3 = q; // पॉइंटर टू कंटिन्यू इंट

दूसरे शब्दों में, चर से पहले क्वालीफायर तुरंत होता है
परिभाषा का पहला शब्द।


जवाब 5:
कब्ज और संकेत:

एक पॉइंटर से कंटीन्यू और ए के बीच अंतर करना महत्वपूर्ण है
एक चर के लिए निरंतर सूचक।

यहाँ एक पॉइंटर को स्थिरांक पर रखा गया है:

  const int * p;

निम्न कथन अवैध है, क्योंकि यह परिवर्तन का प्रयास करता है
एक स्थिर मूल्य:

  * पी = 3;

लेकिन यह एक कानूनी है, क्योंकि सूचक स्वयं एक स्थिर नहीं है:

  p = & x;

दूसरी ओर, यह घोषणा एक चर के लिए एक निरंतर सूचक दिखाती है।

  int * const p;

उस स्थिति में, निम्न कथन कानूनी है, क्योंकि परिवर्तनशील को बदला जा सकता है:

  * पी = 3;

लेकिन यह एक नहीं है, क्योंकि यह एक स्थिर मूल्य को बदलने का प्रयास करता है।

  p = & x;

निरंतर पॉइंटर को स्थिर घोषित करना संभव है। उस में
मामले में न तो पॉइंटर का मूल्य और न ही आधार डेटा का मूल्य
आइटम बदला जा सकता है:

  const int * कॉन्स्ट पी;


यहाँ वाक्य विन्यास को याद करने का एक तरीका है (बज़्ने स्ट्रॉस्ट्रुप से):

ध्यान दें कि कॉन्स्ट पॉइंटर्स में, "कॉन्स्ट" हमेशा "*" के बाद आता है। के लिये
उदाहरण:

  int * const p1 = q; // निरंतर चर के लिए सूचक
  int const * P2 = q; // पॉइंटर टू कंटिन्यू इंट
  const int * p3 = q; // पॉइंटर टू कंटिन्यू इंट

दूसरा तरीका यह है कि '*' के बारे में सबसे बड़ा वामपंथी कब्जा करने के बारे में सोचें
इकाई है कि यह कर सकते हैं। 'कांस्ट' सबसे छोटी इकाई को छोड़ता है, जो बाएं या दाएं,
वह कर सकता है। तो ऊपर दिए गए उदाहरणों के बारे में सोचें:

  (int *) const p1 = q; // निरंतर चर के लिए सूचक
  (int const) * पी 2 = क्यू; // पॉइंटर टू कंटिन्यू इंट
  (const int) * p3 = q; // पॉइंटर टू कंटिन्यू इंट

दूसरे शब्दों में, चर से पहले क्वालीफायर तुरंत होता है
परिभाषा का पहला शब्द।