إستخدام مصفوفة كجزء من مصفوفة

عندما كتبت هذا السؤال كنت أعلم ان القليل من سيقوم بالرد عوضا عن الحل لأن مثل هذه الأسئلة قلما تحتاج إليها، و لكن المشكلة هنا ليست فى احتياجك إليها من عدمه و لكن المشكلة تكمن فى ان فهمك الراسخ لبعض الأساسيات أمر هام جدا و هو ما اغلبنا يقوم بتجاوزه او الأسوء ان اغلب الكتب البرمجيه - إن لم يكونوا جميعهم - يتجاوزوا عن شرحهم. فإن كنت درست ++C لفتره طويله فستعرف ما اتكلم عنه من خلال قرائتك للأسطر التالية.
 
عندما نتكلم عن المصفوفات فأغلب ما تجد نفسك تتعامل معه هو المصفوفات الديناميكية، لأنها فى النهايه مؤشر ذات نوع محدد يمكنك تحويله لمؤشر ذات نوع أخر و التلاعب به كما تشاء، و لكن المصفوفات العاديه - التى توضع فى الـ stack - قليل ما يتم التلاعب بها.
 
قبل ان اضع الحل لابد ان تفهم كيفية عمله، فى المعتاد عندما تقابل الكود التالي:

int* p

فأنت تقرأه p هو مؤشر لقيمة أو أكثر من نوع int، و إذا سُئلت عن نوع المتغير p ستقول مؤشر لـ int، التعريف التالي:

int p[7];

يقرأ p هو مصفوفة من 7 عناصر بنوع int، الصعوبه هنا تكمن فى نوع المتغير p حيث العديد يجيب بأن نوع p هو int و ذلك لأنهم اعتادوا أن النوع دائما يكون تعريفه فى أقصى اليسار من المتغير - مثل المؤشرات و المراجع - و لكن من درس اللغه جيدا سيعرف ان نوع p هو مصفوفة من 7 عناصر بنوع int، و يمكنك كتابة typedef لوصف المصفوفة كالتالي:

typedef int array7[7];

و عند إستخدامه:

array7 p;

و هو يماثل نفس تعريف المصفوفة الذى نستخدمه طول الوقت.
 
 
لنأت لموضوع تحويل الأنواع، عند إستخدام المؤشرات يمكنك تحويل نوع مؤشر لنوع مؤشر أخر كالتالي:

int* a = new int[10];char* p = (char*)a;

كما ترى المؤشر p سيسمح لك بالتعامل مع المكان الذى يشير إليه المؤشر a على مستوى البايت^[1]، و لكن ماذا سيحدث إذا تحرير و إعادة حجز الذاكره التى يشير إليها المتغير a، حينها المؤشر p أصبح تالف لأن قيمة المؤشر p هى موقع الذاكره الذى تم حجزه أول مره - الموجود بالكود - و ليس موقع المتغير a داخل الذاكره حيث إذا كان p هو موقع a بالذاكرة حينها مهما كانت عنوان الذاكره الموجود بـ a فسيكون نفس العنوان داخل p.
 
يمكن إستخدام مؤشر لمؤشر لإتمام هذه العملية كالتالي:

int* a = new int[10];char** p = (char**)&a;

إستخدام مؤشر لمؤشر هو الإسلوب الأمثل فى هذه الحالة، و لكن لازال يعيبه انه يشير لمكان محدد فإذا كان محتوى المؤشر a هو عنوان لمكان أخر فستحتاج لمستوى جديد من المؤشرات. لغة ++C لديها إضافه جميله لهذا الأمر تسمى مرجع، و المرجع يختلف كثيرا عن المؤشرات و توجد بعض الامور داخل اللغه لا يمكن تنفيذها إلا بإستخدام المراجع.
 
على خلاف المؤشر فالمرجع لا عنوان له، أى أنه لا يحجز مساحه بالذاكره، أنظر الكود التالي:

int a = 10;
int& b = a;

b = 12;

cout << boolalpha << (&a == &b) << endl;

السبب فى ان المرجع لا عنوان له يعود ان قيمة المرجع النهائية هي قيمة المتغير الغير مرجع الذى يشير له:

int a = 10;
int& b = a;
int& c = b;
int& d = c;

d = 12;

cout << hex << &a << endl;
cout << hex << &b << endl;
cout << hex << &c << endl;
cout << hex << &d << endl;

فى هذا المثال سترى ان كل مرجع يشير للمرجع الذى قبله فإذا حدث و أن كان المرجع له عنوان حينها المتغيران c و d لن يشيران لقيمة المتغير a و إنما لسلسلة المراجع التى قبلهم، و لكن هذا سيصبح خاطئ لأنك حينها ستحتاج للأنواع مرجع و مرجع و لمرجع و هكذا، أى اننا اصبح لدينا مسمسى جديد للمؤشرات و لكن بإستخدام المراجع.
 
لهذا السبب كان المرجع لا عنوان له و بهذا اصبح مجرد مسمى أخر للمتغير الذى له عنوان و يحتوى على قيمه، و لهذا فى المثال السابق المرجع b هو نفسه المتغير a و بالتالي عند إسناد قيمة b إلى c فأنت فعليا تسند قيمة a إلى c و نفس الأمر مع d حيث أصبح هو a.
 
لتتأكد من ان المرجع لا عنوان له أنظر المثال  التالي:

int a = 1;
int b = 2;

int& c = a;
int& d = c;

d = 10; // value of a became 10

c = b; // c refer to b

d = 13;

cout << a << endl << b << endl;

فى هذا المثال c يشير لـ a و d يشير لـ c، بعدها تم تغيير قيمة d لتصبح 10 و من تسلسل المرجع فهذا يعنى ان قيمة a أصبحت 10، بعدها تم جعل c يشير لـ b و من ثم تم تغيير قيمة d، الأن إذا كان المرجع له عنوان فإن d يشير لـ c و بالتبعيه فإن d يشير لـ b و بهذا عند تغيير قيمة d إلى 13 فإننا نغير قيمة b إلى 13.
 
عند تشغيل البرنامج ستجد أن قيمة a هى تغيرت دائما و هذا يعنى ان المرجع لا عنوان له.
 
لأن المرجع لا عنوان له لابد دائما ان يشير لشئ ما، و لهذا عند تعريفه لابد من وضع قيمه له.
 
هل تذكر المثال الذى استخدمنا فيه مؤشر لمؤشر، أنظر إليه الأن:

int* a = new int[10];char*& p = (char*&)a;

نوع المتغير p يقرأ من اليمين لليسار ليصبح مرجع لمؤشر من نوع char، لاحظ أيضا ان قيمة المتغير a لابد من ان يتم تحويلها لهذا النوع حتى تستطيع إسناده إلى p.
 
لنعود للمصفوفات.
 
عندما نقوم بتعريف مرجع فإننا نكتب النوع يليه علامة & و هذا يعطينا نوع جديد بالإسم مرجع لنوع و هذا يعنى ان المترجم عندما يرى هذه الصيغه - مرجع لنوع - فإنه يعلم انه سيقوم بربط إسم لمتغير موجود، المشكله تظهر عندما تقوم يكتابة الكود التالي:

int& p[10];

لنقرأ الإسم معا، p هو مصفوفة من 10 عناصر بنوع مرجع لـ int، و لكن أنتظر عناصر المصفوفه لكل منها عنوان بالذاكره فكيف يمكن إنشاء مصفوفه بعناصر كل منها مرجع و لا يوجد لها عنوان و هنا يتوقف المترجم و يظهر رسالة خطأ تشبه التاليه:

arrays of references are illegal

و لكن p هو متغير من نوع مصفوفه و شانه شان كافة المتغيرات و أريد ان اقوم بتعريف مرجع له فكيف أفعلها؟
 
لتعرف كيف تقوم بهذا الأمر إسمح لى أن أعطيك مراجعه سريعه فى تعريف المتغيرات، أنظر المثال التالي:

int a, b ,c;
int &ar = a, &br = b, &cr = c;
int *ap, *bp, *cp;

int x[10];

int (*sum)(int a, int b);

أما السطر الأول فيقوم بتعريف ثلاثة متغيرات من نوع int، و السطر الثاني يقوم بتعريف ثلاثة مراجع للمتغيرات التى تم تعريفها بالسطر الأول، السطر الثالث يقوم بتعريف ثلاثة مؤشرات لـ int، السطر الرابع يعرف مصفوفه بالإسم x من عشرة عناصر بالنوع int، السطر الأخير يعرف مؤشر دالة إسمه sum و يأخذ معاملين كلاهما نوعه int.
 
ما يهمنى هنا تذكريك بالسطر الثاني و الثالث و الأخير حيث الأوليين تم ربط علامة مالرجع و المؤشر بإسم المتغير و ليس بإسم النوع و بالمثل عندما تم تعريف إسم مؤشر الدالة فإن علامة المؤشر لإسم الدالة.
 
قبل أن تقفذ للإستنتاجات، الكود السابق يمكن كتابته بالشكل التالي:

int (a), (b), (c);
int (&ar) = a, (&br) = b, (&cr) = c;
int (*ap), (*bp), (*cp);

int (x)[10];
int (x2[10]);

int (*sum)(int a, int b);

هل بدءت فى شد شعرك بعد!!
 
بشكل عام كل شئ بعد إسم النوع و إلى نهاية إسم المتغير يطلق عليه declarators - و هو الفصل الثامن فى توثيق اللغه - و حيث انه توجد العديد من أشكال تعريف المتغيرات فإن المترجم أحيانا يختلط عليه الأمر و لا يعرف كيف يربط بين المعاملات المستخدمه مع الإسم او لا يعرف ماذا تقصد بإستخدام لمعامل معين مع إسم معين لذا يتم إستخدام الأقواس لجعل الصيغه التى تستخدمها لا تحتمل أكثر من معني.
 
هل تذكر لماذا استخدمنا الأقواس مع تعريف مؤشرات الدوال؟
السبب يعود لأن إن لم تستخدم الأقواس لتغليف معامل المؤشر مع الإسم سيتم ربط علامة المؤشر مع النوع و ستعطي مسمى مختلف حيث بدلا من تعريف مؤشر دالة ستقوم بالتصريح عن دالة تعيد مؤشر.
 
الأن هل عرفت الهدف الذى يستخدم من أجله الأقواس فى تعريف المتغيرات (لا اعتقد انه يوجد كتاب - قراته على الاقل - يتكلم عن هذه النقطه أو بعض مما سبق).
 
لنعود للمصفوفات مره أخرى: هل تذكر المشكله بهذا الكود:

int& p[10];

أعتقد أنك تعرف الحل الان:

int (&p)[10];

لاحظ انك لو ضممت عدد عناصر المصفوفه داخل الأقواس كالتالي:

int (&p[10]);

فإن هذا التعريف يطابق التعريف الذى يصدر الخطأ لأنه فى هذه الحالة - كما التى تصدر الخطأ - يتم ربط إسم المصفوفه بعدد العناصر قبل الربط على المرجع (يمكنك تخيل العملية أنها تبدأ من إسم المتغير ثم اليمين بالكامل فاليسار و هكذا حتى يتم الإنتهاء من التعريف) و فى حاتنا هذه فيتم قراءة إسم المصفوفه يليها عدد العناصر يليها المرجع و هنا يتم ربطه على العناصر و ليس إسم المصفوفه ثم العنوان، و يقرأ p هو مصفوفه من 10 عناصر مرجعيه بنوع int.
 
أما التى فيها عدد العناصر خارح الأقواس فيتم قراءة الإسم و اليمين فارغ و اليسار يحتوى على علامة المرجع و بهذا يعلم المترجم ان الإسم p هو مرجع ويخرج من الأوقاس و يقرأ العناصر العشره فيعلم ان الإسم p هو مرجع لمصفوفة من عشر عناصر ثم يقرأ النوع int فيعلم ان p هو مرجع لمصفوفه من عشر عناصر بنوع int
 
الأن قمنا بربط كافة الأساسيات التى نحتاجها معا و بقي لنا التطبيق فى الإجابه على السؤال الأصلي:
 
السؤال يحدد أن المصفوفه arr و arr2 يحتلا نفس المساحه من الذاكره، لذا الأمر الإفتراضي الذى لابد ان يتطرق إلى الأذهان هو ان كلا المصفوفتين موجودين داخل union و لكن السؤال يحدد أن المصفوفه arr2 لها عدد عناصر أصغر و تبدأ من العنصر الثاني داخل المصفوفه arr و هذا يعنى اننا سنقوم بعمل إزاحة للمصفوفه arr و من ثم الحصول على مرجع بدءا من هذا العنصر و بعدد العناصر التى نحتاجها.
 
دعنى افصلها لك خطوه خطوه:
 
1- سنقوم بعمل إزاحة للمصفوفه arr للموقع المحدد، الإزاحه ليست كما تتوقع و لكن هى فقط الحصول على العنصر الذى نريد أن نجعله أول عنصر فى المصفوفه الجديده:

int& item = arr[2];

لاحظ ان المرجع item مربوط على العنصر ذات الترتيب الثاني فى المصفوفه arr.
 
2- سنقوم بتعريف مرجع للمصفوفه arr2:

int (&arr2)[5];

هذا التعريف غير كامل و لابد من وضع قيمه له حتى يصبح فعال.
 
3- سنقوم بربط المصفوفه arr2 على العنصر item بعد تحويله لنوع المصفوفه arr2:

int (&arr2)[5] = ( int(&)[5] )item;

صيغة النوع الذى سيتم التحويل إليه قد تكون غريبه إليك و لكن إن فكرت بها قليلا ستجدها منطقيه حيث انك تقوم بتحويل إلى مرجع لمصفوفه من 5 عناصر بنوع int و هذا ما تعنيه صيغة التحويل.
 
المثال بالكامل:

#include <iostream>using namespace std;int main(){    int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};    int (&arr2)[5] = (int(&)[5])(arr[2]);    cout << "arr[0]=" << arr[0];    for(int i=1; i<10; i++)        cout << ", arr[" << i << "]=" << arr;    cout << endl;    const int arr2_len = sizeof(arr2)/sizeof(int);    for(int i=0; i<arr2_len; ++i)        arr2 += 5;    cout << "arr[0]=" << arr[0];    for(int i=1; i<10; i++)        cout << ", arr[" << i << "]=" << arr;    cout << endl;    cout << "arr2[0]=" << arr2[0];    for(int i=1; i<arr2_len; i++)        cout << ", arr2[" << i << "]=" << arr2;    cout << endl;}

الفكره التى طبقناها هنا تسمى بـ array view و التى تسمح لك بالتعامل مع جزء من المصفوفه كانها مصفوفه منفصله، هذه الفكره لها تطبيقات عديده مثل التعامل مع جزء من النص كأنه نص منفصل.

و الله ولي التوفيق
 
 
^[1] المسمى الصحيح هنا ليس البايت و إنما الوحدة حيث ان مساحة النوع char تساوى 1، و هذا الواحد مهما كان عدد البتات به فيطلق عليه إسم الوحده و مساحة كافة أنواع اللغه تقاس بالنسبه له، فالنوع signed short يستطيع ترميز قيم ضعف التى يستطيع ترميزها النوع signed char و بالتالي فحجم النوع signed short ضعف حجم النوع signed char و حيث ان الأنواع char و signed char و unsigned char كل منهم مساحته 1 وحدة بالتالي مساحة النوع signed short و unsigned short هو 2 وحدة و هى النتيجه التى من المفترض ان يعيدها مترجمك عند إستخدام اى النوعين مع المعامل sizeof.