परिचय

निम्नलिखित प्रश्न दिखाते हुए हाल ही में उन्होंने मुझसे प्रश्न किया, "यह क्या है और इसका उपयोग कैसे करना है?"

extern "C" { void byteMaskDowngrade(byte***const byteMask, const byte *const *const && source) { // - . } //  . } 

यह सहकर्मी मेरा काम करने वाला सहकर्मी था और हमें तुरंत समझ में नहीं आया कि फ़ंक्शन घोषणा में वास्तव में पैरामीटर का क्या मतलब है (उन लोगों के लिए जो रुचि रखते हैं जहां इस तरह की घोषणा की आवश्यकता हो सकती है: क्रिप्टोग्राफी में)।

और कार्यशाला में सहयोगियों से संभावित समस्याओं की प्रत्याशा में, मैंने इस लेख को बनाने का फैसला किया, इसे एक धोखा पत्रक के रूप में रखा, अर्थात् दो प्रश्नों के उत्तर:

1. ऐसे विज्ञापन यहाँ कैसे लिखें?
2. और उन्हें सही तरीके से कैसे पढ़ा जाए?

"*"

एक तारांकन के साथ मामला सबसे आम है, हालांकि, गलतफहमी यहां भी संभव है:

• कैसे करें:
  
  
  • इसलिए:
    
    

     const byte p; 

  • या तो:
    
    

     byte const p; 

  
  
• या प्रविष्टि '*' के मामले में:
  
  
  • इसलिए:
    
    

     byte *const p; 

  • या तो:
    
    

     const byte *p; 

कड़ाई से बोलना, संकलक के दृष्टिकोण से, एक तारांकन की उपस्थिति और अभिव्यक्ति में इसकी स्थिति एक किनारे प्रश्न बनती है क्योंकि प्रविष्टि का अंतिम अर्थ अलग होगा। उपरोक्त मामले में कास्ट स्पेसियर की उपस्थिति से डेटा प्रकार के सापेक्ष उसकी स्थिति पर विचार करने पर कोई फर्क नहीं पड़ता है, हालांकि, स्थिति नाटकीय रूप से बदलती है जब संकेत दिखाई देते हैं: एक, दो, तीन ... ठीक है, आप समझते हैं:

 void p() { //   . byte * a = new byte{1}; a++; // . a[0]++; // . //    . const byte * b = new byte{1}; b++; // . //b[0]++; // . //    . byte *const c = new byte{1}; //c++; // . c[0]++; // . //     . const byte *const d = new byte{1}; //d++; // . //d[0]++; // . } 

यह सब तब और दिलचस्प लगता है जब दूसरा पॉइंटर दिखाई देता है (यहाँ लिखने के लिए एक कुशल पढ़ने का नियम पहले से ही पता लगाया जा रहा है):

 void pp() { //     . byte ** a = new byte * { new byte{1} }; a++; // . a[0]++; // . a[0][0]++; // . //      . const byte ** b = new const byte * { new byte{1}}; b++; // . b[0]++; // . //b[0][0]++; // . //      . byte *const * c = new byte * { new byte{1}}; c++; // . //c[0]++; // . c[0][0]++; // . //      . byte * *const d = new byte * { new byte{1}}; //d++; // . d[0]++; // . d[0][0]++; // . //       . const byte *const * e = new const byte *const { new byte{1}}; e++; // . //e[0]++; // . //e[0][0]++; // . //       . const byte * *const f = new const byte * { new byte{1}}; //f++; // . f[0]++; // . //f[0][0]++; // . //       . byte *const *const g = new byte *const { new byte{1}}; //g++; // . //g[0]++; // . g[0][0]++; // . //        . const byte *const *const h = new const byte *const { new byte{1}}; //h++; // . //h[0]++; // . //h[0][0]++; // . } 

जैसा कि आप देख सकते हैं, एक डबल पॉइंटर को 8 अलग-अलग तरीकों से दर्शाया जा सकता है, जिनमें से प्रत्येक लक्ष्य डेटा का उपयोग करने के एक विशेष तरीके को परिभाषित करता है।

इस तरह के भाव पढ़ने के नियम इस प्रकार हैं:

• अभिव्यक्ति में '=' ​​चिह्न देखें और अभिव्यक्ति को दाईं से बाईं ओर पढ़ें;
• चर का नाम छोड़ें;
• आगे की बैठक या तो '*', जिसका अर्थ है एक नियमित सूचक, या '* कास्ट' - एक स्थिर सूचक;
• इस प्रकार हम तब तक पढ़ते हैं जब तक डेटा प्रकार (बाइट) का सामना नहीं हो जाता;
• और डेटा प्रकार के बाईं ओर अंतिम शब्द कास्ट हो सकता है, जिसकी उपस्थिति का अर्थ है कि यह संपूर्ण निर्माण डेटा को संदर्भित करता है जिसे बदला नहीं जा सकता है; यदि कब्ज नहीं है, तो यह संभव है।

लिखने और पढ़ने का यह रूप सबसे परिष्कृत भावों को पढ़ना और समझना आसान बनाता है)

यहां ट्रिपल पॉइंटर के साथ अभिव्यक्ति के पूर्ण सेट का एक उदाहरण दिया गया है:

"***"

 void ppp() { //       . byte *** a = new byte * * { new byte * {new byte{1}} }; a++; // . a[0]++; // . a[0][0]++; // . a[0][0][0]++; // . //        . const byte *** b = new const byte * * { new const byte * {new byte{1}} }; b++; // . b[0]++; // . b[0][0]++; // . //b[0][0][0]++; // . //        . byte*const * * c = new byte *const * { new byte *const {new byte{1}} }; c++; // . c[0]++; // . //c[0][0]++; // . c[0][0][0]++; // . //        . byte * *const * d = new byte * *const { new byte * {new byte{1}} }; d++; // . //d[0]++; // . d[0][0]++; // . d[0][0][0]++; // . //        . byte *** const e = new byte * * { new byte * {new byte{1}} }; //e++; // . e[0]++; // . e[0][0]++; // . e[0][0][0]++; // . //         . const byte *const * * f = new const byte *const * { new const byte *const {new byte{1}} }; f++; // . f[0]++; // . //f[0][0]++; // . //f[0][0][0]++; // . //         . const byte * *const * g = new const byte * *const{ new const byte * {new byte{1}} }; g++; // . //g[0]++; // . g[0][0]++; // . //g[0][0][0]++; // . //         . const byte * * *const h = new const byte * *{ new const byte * {new byte{1}}}; //h++; // . h[0]++; // . h[0][0]++; // . //h[0][0][0]++; // . //         . byte *const * *const i = new byte *const * { new byte *const {new byte{1}}}; //i++; // . i[0]++; // . //i[0][0]++; // . i[0][0][0]++; // . //         . byte * *const *const j = new byte * *const { new byte * {new byte{1}}}; //j++; // . //j[0]++; // . j[0][0]++; // . j[0][0][0]++; // . //         . byte *const *const * k = new byte *const *const {new byte *const{new byte{1}}}; k++; // . //k[0]++; // . //k[0][0]++; // . k[0][0][0]++; // . //           const //           . const byte *const *const *const m = new const byte *const *const {new const byte *const {new byte{1}}}; //m++; // . //m[0]++; // . //m[0][0]++; // . //m[0][0][0]++; // . }