مصفوفة ثنائية الأبعاد

المصفوفة ثنائية الأبعاد في لغة C++ هي بنية تسمح لك بتخزين العناصر في شكل جدولي، منظمة في صفوف وأعمدة. إنها في الأساس مجموعة من المصفوفات.

فيما يلي شرح لمصفوفة ثنائية الأبعاد في لغة C++:

• الإعلان والتهيئة:

// Declaration of a 2D array
int matrix[3][4];

// Initialization of a 2D array
int anotherMatrix[2][3] = { {1, 2, 3}, {4, 5, 6} };

• البناء:

في المصفوفة ثنائية الأبعاد، يتم ترتيب العناصر في صفوف وأعمدة. يمثل الـindex الأول الصف، ويمثل الـindex الثاني العمود.

• تمثيل الذاكرة:

في الذاكرة، يتم تخزين مصفوفة ثنائية الأبعاد في كتلة متجاورة من الذاكرة. يتم تخزين عناصر كل صف معًا، ويتم تخزين الصفوف واحدًا تلو الآخر.

• الوصول إلى العناصر:

int value = matrix[1][2];  // Accessing the element in the second row and third column

• التهيئة باستخدام الحلقات المتداخلة:

العمليات المشتركة:

– التكرار من خلال العناصر باستخدام الحلقات المتداخلة.
- إجراء العمليات على كل عنصر.
- تمرير مصفوفة ثنائية الأبعاد إلى الدوال.

مثال 1:

#include <iostream>
using namespace std;
int main()
{
    int a[3][4];
    for (size_t i = 0; i < 3; i++)
    {
        for (size_t j = 0; j < 4; j++)
        {
            cin >> a[i][j];
        }
    }
    for (size_t r = 0; r < 3; r++)
    {
        for (size_t c = 0; c < 4; c++)
        {
            cout << a[r][c] << " ";
        }
        cout << endl;
    }
    return 0;
}

يسمح هذا الكود للمستخدم بإدخال القيم في مصفوفة ثنائية الأبعاد [3] [4] ثم طباعة المصفوفة في شكل جدول.

النقاط الرئيسية:

1. إدخال مصفوفة ثنائية الأبعاد:
   تُستخدم الحلقات المتداخلة (for Loops) للتكرار على كل عنصر من عناصر المصفوفة ثنائية الأبعاد وإدخال القيم باستخدام cin.
2. مخرجات مصفوفة ثنائية الأبعاد:
   يتم استخدام مجموعة أخرى من الحلقات المتداخلة للتكرار على كل عنصر من عناصر المصفوفة ثنائية الأبعاد وإخراج القيم باستخدام cout.
   تطبع الحلقة الداخلية كل صف، وتنتقل الحلقة الخارجية إلى الصف التالي، مما يؤدي إلى إنشاء نموذج جدولي.
3. مخرجات الجدول:
   الـcout << a[r][c] << ” “;i تقوم بطباعة كل عنصر من عناصر المصفوفة ثنائية الأبعاد متبوعة بمسافة.
   الك cout << endl; تستخدم للانتقال إلى السطر التالي بعد طباعة كل صف.
4. تفاعل المستخدم:
   يُطلب من المستخدم إدخال قيم لكل عنصر في المصفوفة ثنائية الأبعاد. ومن المتوقع أن يتم توفير المدخلات بطريقة حكيمة.
5. حجم المصفوفة:
   يتم الإعلان عن المصفوفة a بثلاثة صفوف وأربعة أعمدة، مما يؤدي إلى إنشاء مصفوفة 3 × 4.

يسمح هذا الرمز للمستخدم بإدخال القيم بشكل تفاعلي في مصفوفة 3 × 4 ثنائية الأبعاد ثم يعرض المصفوفة بتنسيق جدولي.

مثال 2:

#include <iostream>
using namespace std;

int main() {
    // Initialization of a 2D array with predefined values
    int arr[2][4] = {{1, 1, 1, 1}, {2, 2, 2, 2}};
    
    // Variable to store the sum of array elements
    int sum = 0;

    // Nested loops to iterate over each element of the 2D array
    for (size_t r = 0; r < 2; r++) {
        for (size_t c = 0; c < 4; c++) {
            // Accumulate the values to calculate the sum
            sum += arr[r][c];
        }
    }

    // Output the sum of array elements
    cout << "sum = " << sum << endl;

    return 0;
}

المخرجات:

في هذا المثال المحدد، يتم حساب المجموع على النحو التالي: 1 + 1 + 1 + 1 + 2 + 2 + 2 + 2 = 12.
سيكون الناتج المجموع = 12.

يعد هذا الكود توضيحًا بسيطًا لكيفية التكرار على العناصر في مصفوفة ثنائية الأبعاد وتنفيذ عملية أساسية، في هذه الحالة، حساب مجموع جميع العناصر.

مثال 3:

#include <iostream>
using namespace std;
int main()
{
    int marks[10][5];
    for (size_t r = 0; r < 10; r++)
    {
        for (size_t c = 0; c < 5; c++)
        {
            cout << "Enter mark " << c + 1 << " " << "for student " << r + 1 << ": " << endl;
            cin >> marks[r][c];
        }
    }
    double s = 0;
    float avg[10];
    for (size_t r = 0; r < 10; r++)
    {
        s = 0;
        for (size_t c = 0; c < 5; c++)
        {
            s += marks[r][c];
        }
        avg[r] = s / 5;
        cout << "Average for student #" << r + 1 << " = "<< avg[r] << endl;
    }
    return 0;
}

يقوم هذا الكود بجمع علامات 10 طلاب في 5 مواد، وحساب متوسط العلامة لكل طالب، ثم إخراج المتوسط لكل طالب.

مثال 4:

#include <iostream>
using namespace std;
int main()
{
    char MTXchar[5][5] = {{'*','$','$','$','$'},
                          {'$','*','$','$','$'},
                          {'$','$','*','$','$'},
                          {'$','$','$','*','$'},
                          {'$','$','$','$','*'}};
                          
    for (size_t r = 0; r < 5; r++)
    {
        for (size_t c = 0; c < 5; c++)
        {
            
            if (c == r)
                cout << MTXchar[r][c];
            else
                cout << " ";
        }
        cout << endl;
    }
    return 0;
}

يعرف هذا الكود مصفوفة 5 × 5 (MTXchar) تحتوي على نجوم "على القطر الرئيسي وأحرف "$" في مكان آخر. ثم يقوم بعد ذلك بطباعة النجوم الموجودة على القطر الرئيسي فقط، مما ينتج عنه خط قطري مكون من "نجوم".

المخرجات:

يُخرج الكود سطرًا قطريًا من النجوم على شاشة المخرجات.

*    
 *   
  *  
   * 
    *

يتضمن تمرير مصفوفة ثنائية الأبعاد إلى دالة في لغة C++ تحديد المصفوفة كـparameter في إعلان الدالة. نظرًا لأن المصفوفة ثنائية الأبعاد هي في الأساس مصفوفة من المصفوفات، فأنت بحاجة إلى تحديد حجم الأعمدة (نظرًا لأن الصفوف معروفة ضمنيًا بناءً على عدد المصفوفات).

• إعلان الدالة:

عند الإعلان عن دالة تقبل مصفوفة ثنائية الأبعاد، فإنك تحتاج إلى تحديد parameter المصفوفة بالإضافة إلى حجم الأعمدة. لم يتم تحديد حجم الصفوف بشكل صريح.

void functionName(int arr[][COLS], size_t rows, size_t cols) {
    // Function logic using arr
}

- int arr[][COLS]: تشير إلى أن الدالة تأخذ مصفوفة ثنائية الأبعاد من الأعداد الصحيحة مع عدد محدد من الأعمدة (COLS).
- size_trows: يمكن استخدام هذا الـ parameter لتمرير عدد الصفوف في المصفوفة.
– size_t cols: يمكن استخدام هذا الـparameter لتمرير عدد الأعمدة في المصفوفة

• إستدعاء الدالة:

عند استدعاء الدالة، تحتاج إلى توفير المصفوفة ثنائية الأبعاد الفعلية بالإضافة إلى عدد الصفوف والأعمدة.

int myArray[ROWS][COLS];
functionName(myArray, ROWS, COLS);

– myArray: اسم المصفوفة ثنائية الأبعاد التي تريد تمريرها.
- ROWS: عدد الصفوف في المصفوفة.
- COLS: عدد الأعمدة في المصفوفة.

مثال 5:

#include <iostream>
using namespace std;
void f(int arr[][5], int r)
{
    for (size_t i = 0; i < r; i++)
    {
        for (size_t j = 0; j < 5; j++)
        {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }
}
int main()
{
    int a[2][5] = {1,2,3,4,5,
                   10,20,30,40,50};
    f(a, 2);
    return 0;
}

تأخذ الدالة f مصفوفة ثنائية الأبعاد (arr) وعدد صفوفها (r) كـparameters.
يستخدم حلقات متداخلة للتكرار على كل عنصر من عناصر المصفوفة وطباعة العناصر في شكل جدول.

تستدعي الوظيفة الرئيسية الدالة f مع المصفوفة ثنائية الأبعاد a وعدد الصفوف (2) كـarguments.

المخرجات:

سيكون ناتج هذا الكود عبارة عن عناصر المصفوفة ثنائية الأبعاد المطبوعة في شكل جدول.

ستبدو المخرجات كما يلي:

1 2 3 4 5 
10 20 30 40 50 

• تبديل المصفوفة

تبديل المصفوفة هو عملية تقلب المصفوفة، وتبديل مؤشرات الصفوف والأعمدة في المصفوفة. بمعنى آخر، إذا كانت المصفوفة الأصلية تحتوي على عناصر في الموضع (i, j)، فستحتوي المصفوفة المنقولة على العنصر في الموضع (j, i).

مثال 6:

#include <iostream>
using namespace std;
int main()
{
    int arr[3][3];
    for (size_t i = 0; i < 3; i++)
    {
        for (size_t j = 0; j < 3; j++)
        {
            cin >> arr[i][j];
        }
    }
    cout << "Matrix is: \n";
    for (size_t i = 0; i < 3; i++)
    {
        for (size_t j = 0; j < 3; j++)
        {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }
    cout << "Transpose matrix is:\n";
    for (size_t i = 0; i < 3; i++)
    {
        for (size_t j = 0; j < 3; j++)
        {
            cout << arr[j][i] << " ";
        }
        cout << endl;
    }

    return 0;
}

يأخذ هذا الكود مدخلات المستخدم لمصفوفة 3 × 3، ويطبع المصفوفة الأصلية، ثم يطبع تبديلها.

النقاط الرئيسية:

1. المدخلات:
   تأخذ الحلقات المتداخلة مدخلات المستخدم لمصفوفة 3×3.
2. مخرجات المصفوفة الأصلية:
   بعد أخذ المدخلات، يقوم الكود بإخراج المصفوفة الأصلية.
3. تبديل مخرجات المصفوفة:
   مجموعة أخرى من الحلقات المتداخلة تنتج تبديل المصفوفة. تقوم بتبديل مؤشرات الصفوف والأعمدة.

مثال على المخرجات:

إذا أدخل المستخدم ما يلي:

1 2 3
1 2 3
1 2 3

ستكون المخرجات كالتالي:

Matrix is: 
1 2 3 
1 2 3 
1 2 3 
Transpose matrix is:
1 1 1 
2 2 2 
3 3 3