المصفوفات ثنائية الأبعاد في لغة C: المصفوفات متعدّدة الأبعاد وتوزيع الذاكرة والمصفوفات الرياضية

المصفوفة متعدّدة الأبعاد مصفوفة عناصرها مصفوفات بدورها. فـ int grid[3][4]; ليست نوع شبكة خاصًّا - بل ثلاثة عناصر، كلٌّ منها مصفوفة من أربعة أعداد صحيحة، مخزَّنة متتابعة. وبمجرّد استيعاب ذلك، يتبع بقية الموضوع: التوزيع، وحسابات الفهرسة، والقاعدة المحيّرة بغير ذلك عن تمريرها إلى الدوال.

والبعدان يغطّيان كل استخدام عملي تقريبًا - الشبكات والجداول والمصفوفات الرياضية ورقع الألعاب والصور - فذلك ما تعمل به هذه الصفحة.

التعريف والتهيئة

int grid[3][4];        // 3 rows, 4 columns - 12 ints

الرقم الأول هو عدد الصفوف، والثاني عدد الأعمدة. ويمكن كتابة المهيّئات مسطّحة أو بأقواس معقوفة داخلية؛ والأقواس تستحق الاستخدام لأنها تُظهر الشكل.

#include <stdio.h>

int main(void) {
    int a[2][3] = {{1, 2, 3}, {4, 5, 6}};   // بأقواس لكل صفّ - الأوضح
    int b[2][3] = {1, 2, 3, 4, 5, 6};       // مسطّحة - النتيجة نفسها
    int c[2][3] = {{1, 2}, {4}};            // صفوف جزئية: الباقي أصفار
    int d[2][3] = {0};                      // كل عنصر صفر
    int e[][3]  = {{1, 2, 3}, {4, 5, 6}};   // الصفوف مستنتَجة، والأعمدة مطلوبة

    printf("a: "); for (int i = 0; i < 2; i++) for (int j = 0; j < 3; j++) printf("%d ", a[i][j]);
    printf("\nb: "); for (int i = 0; i < 2; i++) for (int j = 0; j < 3; j++) printf("%d ", b[i][j]);
    printf("\nc: "); for (int i = 0; i < 2; i++) for (int j = 0; j < 3; j++) printf("%d ", c[i][j]);
    printf("\nd: "); for (int i = 0; i < 2; i++) for (int j = 0; j < 3; j++) printf("%d ", d[i][j]);
    printf("\ne: "); for (int i = 0; i < 2; i++) for (int j = 0; j < 3; j++) printf("%d ", e[i][j]);
    printf("\n");

    return 0;
}

وصيغة int e[][3] تهمّ: فيمكنك ترك عدد الصفوف فارغًا ودع المهيّئ يقرّر، أما عدد الأعمدة فليس اختياريًا أبدًا. ويشرح القسم التالي السبب.

توزيع الصفوف أولًا

تخزّن C المصفوفة ثنائية الأبعاد بـترتيب الصفوف أولًا: الصف 0 كاملًا، ثم الصف 1 كاملًا، وهكذا، في كتلة ذاكرة واحدة غير منقطعة. ولا توجد مصفوفة من مؤشّرات الصفوف خلف الكواليس.

int grid[3][4] = {{ 1, 2, 3, 4},
                  { 5, 6, 7, 8},
                  { 9,10,11,12}};

how you picture it            how it actually sits in memory
+----+----+----+----+
|  1 |  2 |  3 |  4 |   row 0   +--+--+--+--+--+--+--+--+--+--+--+--+
+----+----+----+----+           | 1| 2| 3| 4| 5| 6| 7| 8| 9|10|11|12|
|  5 |  6 |  7 |  8 |   row 1   +--+--+--+--+--+--+--+--+--+--+--+--+
+----+----+----+----+            \__ row 0 __/\__ row 1 __/\_ row 2 _/
|  9 | 10 | 11 | 12 |   row 2
+----+----+----+----+           grid[i][j] is at element index i*4 + j

وتلك الصيغة، i * columns + j، هي الآلية كلها - وهي سبب وجوب معرفة المترجم عددَ الأعمدة لفهرسة أي شيء. ولا يدخل عدد الصفوف في الحساب إطلاقًا.

ويمكنك رؤية التوزيع مباشرةً بطباعة العناوين:

#include <stdio.h>

int main(void) {
    int grid[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

    printf("element addresses, in memory order:\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("grid[%d][%d] = %2d at %p\n", i, j, grid[i][j], (void *)&grid[i][j]);
        }
    }

    // الكتلة نفسها مقروءة كمجرى مسطّح من 12 عددًا صحيحًا
    printf("\nflattened: ");
    int *flat = &grid[0][0];
    for (int k = 0; k < 12; k++) {
        printf("%d ", flat[k]);
    }
    printf("\n");

    return 0;
}

تتصاعد العناوين بمقدار sizeof(int) بلا فجوات، بما في ذلك حيث ينتهي صفّ ويبدأ التالي. والحلقة المسطّحة تثبت ذلك - فـ flat[k] تمشي على العناصر الاثني عشر كلها كمجرى واحد.

ولهذا التوزيع نتيجة في الأداء تستحق المعرفة: فالمرور بالصفوف ثم الأعمدة يلمس الذاكرة بالترتيب، وهو ما تحبّه ذاكرة المعالج المخبأة. أما تبديل تداخل الحلقتين بحيث تنزل الحلقة الداخلية في عمود فيقفز بصفّ كامل في كل مرة وقد يعمل أبطأ بعدة أضعاف على مصفوفة كبيرة.

الحلقات المتداخلة

يريد البعدان حلقتَي for: الخارجية تختار الصف، والداخلية تمسح أعمدة ذلك الصف.

#include <stdio.h>

#define ROWS 3
#define COLS 4

int main(void) {
    int grid[ROWS][COLS];

    // املأها بجدول ضرب
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            grid[i][j] = (i + 1) * (j + 1);
        }
    }

    // اطبعها كجدول
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d", grid[i][j]);
        }
        printf("\n");
    }

    // مجاميع الصفوف والمجموع الكلي
    int grand = 0;
    printf("\nrow totals: ");
    for (int i = 0; i < ROWS; i++) {
        int rowSum = 0;
        for (int j = 0; j < COLS; j++) {
            rowSum += grid[i][j];
        }
        grand += rowSum;
        printf("%d ", rowSum);
    }
    printf("\ngrand total: %d\n", grand);

    return 0;
}

سمِّ العدّادات بما تعنيه (i/row للصفوف، وj/col للأعمدة) وأبقِ الترتيب متّسقًا - grid[row][col] في كل مكان. فنصف أخطاء المصفوفات ثنائية الأبعاد زوج فهارس مقلوب.

والأحجام المعرَّفة بـ #define ليست زينة أيضًا: فحدود الحلقة والتعريف لم يعد بإمكانهما الانحراف عن بعضهما حين تغيّر الشكل.

تمرير مصفوفة ثنائية الأبعاد إلى دالة

إليك القاعدة التي توقع بالجميع: يجب أن يصرّح وسيط الدالة بعدد الأعمدة.

#include <stdio.h>

#define COLS 4

// حجم العمود مطلوب؛ وعدد الصفوف يأتي كوسيط منفصل
void print_grid(int grid[][COLS], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d", grid[i][j]);
        }
        printf("\n");
    }
}

// الوسيط نفسه تمامًا، مكتوبًا بصيغة المؤشّر الذي هو عليه فعلًا
void scale_grid(int (*grid)[COLS], int rows, int factor) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < COLS; j++) {
            grid[i][j] *= factor;
        }
    }
}

int main(void) {
    int grid[3][COLS] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

    print_grid(grid, 3);
    scale_grid(grid, 3, 10);
    printf("\nafter scaling:\n");
    print_grid(grid, 3);

    return 0;
}

والسبب هو التحوّل. فتمرير grid يحوّلها إلى مؤشّر إلى عنصرها الأول - وعناصرها صفوف، فالنوع هو int (*)[4]: مؤشّر إلى مصفوفة من 4 أعداد int. ولتعني grid[i][j] شيئًا، يجب أن يعرف المترجم كم يبلغ طول صفّ واحد، وذلك هو الرقم 4. أما عدد الصفوف فغائب فعلًا عن النوع، ولهذا يسافر كوسيط منفصل.

ولاحظ أن int (*grid)[COLS] وint grid[][COLS] هما الوسيط نفسه مكتوبًا بطريقتين - والأقواس مطلوبة، إذ ستكون int *grid[COLS] مصفوفةَ مؤشّرات بدلًا من ذلك. وذلك التمييز مغطّى في المؤشّرات والمصفوفات.

وإن كان عدد الأعمدة معروفًا في وقت التشغيل فقط، فإن الوسائط متغيّرة التعديل في C99 تتيح لك تمريره أولًا:

void print_any(int rows, int cols, int grid[rows][cols]);

ويجب التصريح بـ rows وcols قبل وسيط المصفوفة الذي يستخدمهما. وحيث لا يتوفّر ذلك، يكون البديل الشائع مصفوفة أحادية مسطّحة مع حسابات فهرسة يدوية:

#include <stdio.h>
#include <stdlib.h>

// عامِل كتلة مسطّحة كـ rows x cols وأجرِ الحسابات بنفسك
void print_flat(const int *data, int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%4d", data[i * cols + j]);
        }
        printf("\n");
    }
}

int main(void) {
    int rows = 2, cols = 5;

    int *data = malloc((size_t)rows * cols * sizeof *data);
    if (data == NULL) return 1;

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            data[i * cols + j] = i * 10 + j;
        }
    }

    print_flat(data, rows, cols);
    free(data);
    return 0;
}

data[i * cols + j] هي بالضبط ما يكتبه المترجم نيابةً عنك في حالة الحجم الثابت. وأداؤها يدويًا يكلّف سطرًا واحدًا ويعمل لأي شكل يُقرَّر في وقت التشغيل.

مثال على المصفوفات الرياضية

يجمع ضرب المصفوفات الصفحةَ كلها - ثلاث حلقات متداخلة على تخزين الصفوف أولًا.

#include <stdio.h>

#define N 3

void multiply(const int a[][N], const int b[][N], int out[][N]) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            int total = 0;
            for (int k = 0; k < N; k++) {
                total += a[i][k] * b[k][j];
            }
            out[i][j] = total;
        }
    }
}

void print_matrix(const char *label, const int m[][N]) {
    printf("%s\n", label);
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("%5d", m[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

int main(void) {
    int a[N][N] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int b[N][N] = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}};
    int product[N][N] = {0};

    print_matrix("A:", a);
    print_matrix("B:", b);

    multiply(a, b, product);
    print_matrix("A x B:", product);

    // بدّل صفوف A بأعمدتها في مكانها
    for (int i = 0; i < N; i++) {
        for (int j = i + 1; j < N; j++) {     // ابدأ من i+1 لتبديل كل زوج مرة واحدة
            int temp = a[i][j];
            a[i][j] = a[j][i];
            a[j][i] = temp;
        }
    }
    print_matrix("A transposed:", a);

    return 0;
}

تفصيلان يستحقّان النقل. تقرن حلقة k الداخلية a[i][k] بـ b[k][j] - فأحد الفهرسين يمشي في صفّ والآخر يمشي في عمود. ويبدأ التبديل حلقته الداخلية عند j = i + 1: فالبدء من 0 كان سيبدّل كل زوج مرتين ويترك المصفوفة دون تغيير.

ثلاثة أبعاد وما فوق

يمتدّ النمط، وكذلك القاعدة عن وسائط الدوال - فكل بُعد عدا الأول يجب التصريح به.

#include <stdio.h>

int main(void) {
    // طبقتان، و3 صفوف، و4 أعمدة
    int cube[2][3][4] = {0};

    for (int z = 0; z < 2; z++) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                cube[z][i][j] = z * 100 + i * 10 + j;
            }
        }
    }

    for (int z = 0; z < 2; z++) {
        printf("layer %d:\n", z);
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                printf("%5d", cube[z][i][j]);
            }
            printf("\n");
        }
    }

    printf("\ntotal elements: %zu\n", sizeof cube / sizeof cube[0][0][0]);
    return 0;
}

وعمليًا، الأبعاد الثلاثة هي حيث تبدأ المصفوفات ثابتة الحجم في أن تبدو ثقيلة، وتتحوّل معظم الشيفرة إلى كتلة مسطّحة بفهارس محسوبة أو إلى مصفوفة من البنى تسمّي ما يعنيه كل محور.

أخطاء شائعة

• كتابة grid[i, j]. يقيّم عامل الفاصلة i ويهملها ويفهرس بـ j. وهي تُترجَم. وهي خاطئة. استخدم grid[i][j].
• قلب الفهرسين. فـ grid[col][row] تقرأ عنصرًا حقيقيًا من الموضع الخاطئ، فلا يوجد خطأ يلتقطها. أبقِ ترتيب [row][col] في كل مكان.
• حذف حجم العمود في وسيط. فـ void f(int grid[][]) لا تُترجَم، وذلك هو المترجم ينقذك.
• الخروج عن الحدود. كما في أي مصفوفة، لا يوجد فحص حدود. فـ grid[0][5] على شبكة [3][4] تقرأ grid[1][1] بصمت، لأن التوزيع متّصل والحساب لا يبالي.