सी ++ कॉन्स स्थिर स्थिर घोषणा में दो बार उपयोग किया जाता है

Question

मैंने const को static सरणी की घोषणा में दो बार उपयोग किया है और अब मैं अपनी खुद की स्थिर सरणी बना रहा हूं, मुझे आश्चर्य है कि कुछ परिस्थितियों में दो बार क्यों आवश्यकता होगी।

क्या पॉइंटर्स की एक सरणी एक अंतर बनाती है?

a. static const TYPE name[5]; 
b. static const TYPE const name[5]; 

c. static const TYPE* name[5]; 
d. static const TYPE* const name[5]; 

मेरे समझ के साथ कि b. अमान्य है, लेकिन अगर स्थिरांक दो बार का उपयोग कर मान्य है, अपने उद्देश्य क्या है?

Answer 1

कॉन्स प्रकार * एक्स;

मतलब है कि जिस चीज पर एक्स बिंदु है वह है।

प्रकार * कॉन्स एक्स;

मतलब है कि पॉइंटर एक्स स्थिर है।

संयोजन 2 आपको मिलेगा:

स्थिरांक प्रकार * स्थिरांक x;

मतलब पॉइंटर और चीज दोनों की ओर इशारा करते हैं।

Answer 2

पहले कोड ब्लॉक में आपके पास दूसरी पंक्ति में एक अनावश्यक डुप्लिकेट const है, जिसका कोई प्रभाव नहीं है। (वास्तव में, अच्छे कंपाइलर आपको इसके बारे में चेतावनी देंगे।) आप 5 const TYPE एस की एक सरणी घोषित कर रहे हैं, यही वह है।

दूसरा कोड ब्लॉक दो विभिन्न परिदृश्यों है: पहली पंक्ति, पांच const TYPE रों को परिवर्तनशील संकेत की एक सरणी में आता है, जबकि दूसरा const TYPE रों करने के लिए पाँच निरंतर संकेत की एक सरणी में आता है।

ध्यान दें कि आपको स्थिरांक की एक सरणी शुरू करनी होगी: चूंकि आप बाद में मानों को नहीं बदल सकते हैं, इसलिए उन्हें परिभाषित करने के लिए यह समझ में नहीं आता है।

Answer 3

आप किसी भी प्रकार के सीवी-क्वालीफायर (const या volatile) किसी भी प्रकार के सीवी-योग्य प्रकारों सहित लागू कर सकते हैं - अभी तक एक ही घोषणा में नहीं। हालांकि, वे किसी भी ऑपरेटर की तुलना में अधिक दृढ़ता से बाँध, पूर्वता के मामले में और योग्य प्रकार के दोनों किनारों पर लागू किया जा सकता:

// Let T by any type: 
T const tr; 
const T tl; 
const T const tlr; // only in C 
const const const const const T t5; // only in C 
typedef const T CT; 
CT const tcc; // fine, although CT was already const 

घोषित बिल्कुल वैसा ही, एक निरंतर T। यदि T में पहले से ही सीवी-क्वालीफायर हैं, तो यह अतिरिक्त योग्यता का अर्थ नहीं बदलता है।

अब, प्राथमिकता के लिए; आप कह सकते हैं "मैं एक निरंतर T के लिए सूचक चाहते हैं":

const T (* tp); 

जो आम तौर पर लिखा है

const T* tp; 

क्योंकि const* वैसे भी की तुलना में मजबूत बांधता है के रूप में।

T (* const tp) = 0; // must be initialised, because tp is immutable 

जिसे आम तौर पर

T* const tp = 0; 

लिखा है इसी सबस्क्रिप्ट ऑपरेटर [] है: एक ही पैटर्न में, आप एक ऐसा वैरिएबल "निरंतर लेकिन एक परिवर्तनशील T में बताते हैं" है परिभाषित कर सकते हैं लागू - अभिव्यक्ति के समान वही प्राथमिकता के साथ।

Answer 4

const का उपयोग किसी प्रकार पर दो बार गैर + सी ++ 2003 में अवैध है लेकिन सी ++ 2011 में कानूनी (देखें 7.1.6.1 [decl.type.cv] अनुच्छेद 1: "रिडंडेंट सीवी-योग्यता को अनदेखा किया जाता है।")। जब आप

static const TYPE const name[5]; 

आपने TYPE लगातार दो बार बनाया था। नोट, हालांकि, यह घोषणा सी ++ 2011 में भी गैरकानूनी है, क्योंकि इसे घोषित करते समय आपको const ऑब्जेक्ट प्रारंभ करने की आवश्यकता है।

const TYPE 

और

TYPE const 

के अर्थ बिल्कुल बराबर है: दोनों ही मामलों में आप TYPE वस्तु स्थिर हैं। स्थिरता के लिए, मैं हमेशा const दाहिने ओर रखता हूं क्योंकि शीर्ष-स्तर के प्रकार को छोड़कर प्रत्येक const को दाएं तरफ रखा जाना चाहिए (ठीक है, जब तक कि कुछ कोडिंग दिशानिर्देश अलग-अलग नहीं होते हैं लेकिन मैं मूर्ख कोडिंग दिशानिर्देशों से लड़ रहा हूं)।

पॉइंटर्स का उपयोग करते समय, लगता है कि अलग हो जाते हैं। इसमें दो प्रकार शामिल हैं: प्रकार और पॉइंटर को इंगित करें। इनमें से प्रत्येक को अलग-अलग const बनाया जा सकता है:

TYPE const*  ptr1(0); // non-const pointer to const TYPE 
TYPE* const  ptr2(0); // const pointer to non-const TYPE 
TYPE const* const ptr3(0); // const pointer to const TYPE 

सबसे अच्छा तरीका है यह पता लगाने की क्या किया जाता है const दाईं से बाईं ओर प्रकार घोषणा को पढ़ने के लिए है। बेशक, यह मानता है कि const क्वालीफायर सही स्थान पर डाल दिए जाते हैं। आप उपरोक्त चर्चा में constvolatile या const volatile द्वारा प्रतिस्थापित कर सकते हैं और एक ही तर्क लागू होता है।