مقدمة

لقد اتصلوا بي مؤخرًا بسؤال: "ما هو وكيفية استخدامها؟" ، مع عرض الكود التالي:

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 طرق مختلفة ، كل منها يحدد طريقة خاصة لاستخدام البيانات المستهدفة.

قواعد قراءة هذه التعبيرات هي كما يلي:

• ابحث عن علامة "=" في التعبير وقراءة التعبير من اليمين إلى اليسار ؛
• تخطي اسم المتغير ؛
• اجتماعات أخرى إما "*" ، مما يعني مؤشرًا منتظمًا أو "* const" - مؤشرًا ثابتًا ؛
• وبالتالي نقرأ حتى تتم مصادفة نوع البيانات (البايت) ؛
• والكلمة الأخيرة على يسار نوع البيانات يمكن أن تكون const ، ويعني وجودها أن هذا البناء بالكامل يشير إلى البيانات التي لا يمكن تغييرها ؛ إذا كان const ليس كذلك ، فمن الممكن.

هذا النوع من الكتابة والقراءة يجعل من السهل قراءة وفهم أكثر التعبيرات تطوراً)

فيما يلي مثال على مجموعة كاملة من التعبيرات بمؤشر ثلاثي:

"***"

 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]++; // . }