المصفوفات في لغة C: التعريف والتهيئة والمرور عليها

المصفوفة كتلة ثابتة الحجم من عناصر لها النوع نفسه، موضوعة واحدًا تلو الآخر في الذاكرة. هذا الترتيب المتّصل هو القصة كلها: فهو سبب كون الفهرسة فورية، وسبب الترابط الوثيق بين المصفوفات والمؤشّرات، وسبب قدرة C على تسليمك عنوان العنصر صفر وتركك تعثر على البقية بالحساب.

تعريف مصفوفة

نوع العنصر، والاسم، وحجم بين قوسين معقوفين:

int    scores[5];       // 5 أعداد صحيحة
double prices[100];     // 100 عدد من نوع double
char   initials[3];     // 3 محارف

الحجم هو عدد العناصر، ويجب أن يكون معروفًا في موضع تعريف المصفوفة - عادةً قيمة حرفية أو ثابت معرَّف بـ #define. تُحجَز الذاكرة فورًا؛ ولا يُخصَّص شيء لاحقًا.

تحتوي مصفوفة محلية حديثة التعريف على قيم مهملة، لا على أصفار:

#include <stdio.h>

int main(void) {
    int uninitialized[5];        // المحتويات غير محدّدة
    int zeroed[5] = {0};         // كل عنصر يساوي 0

    printf("zeroed:        ");
    for (int i = 0; i < 5; i++) printf("%d ", zeroed[i]);

    printf("\nuninitialized: ");
    for (int i = 0; i < 5; i++) printf("%d ", uninitialized[i]);
    printf("   <-- whatever was in that memory\n");

    return 0;
}

قد يطبع الصف الثاني أصفارًا، وقد يطبع أعدادًا ضخمة، وقد يختلف بين تشغيل وآخر أو بين بناء تنقيح وبناء إصدار. قراءة تلك القيم سلوك غير معرَّف؛ فهيّئ قبل أن تقرأ.

التهيئة

عدة صيغ، كلها مفيدة:

#include <stdio.h>

int main(void) {
    int a[5] = {10, 20, 30, 40, 50};   // قائمة كاملة
    int b[5] = {1, 2};                 // الباقي يُملأ بالأصفار: 1 2 0 0 0
    int c[5] = {0};                    // المصفوفة كلها أصفار
    int d[]  = {7, 8, 9};              // الحجم مستنتج: 3 عناصر
    int e[5] = {[4] = 99, [0] = 1};    // مُهيِّئات معيَّنة (C99)

    int n = sizeof d / sizeof d[0];

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

    return 0;
}

صيغة {0} هي التي يجدر تذكّرها: أي عناصر لا تذكرها تُهيَّأ بالصفر، فصفر واحد يصفّر المصفوفة كلها. أما المُهيِّئات المعيَّنة ([4] = 99) فتتيح لك ضبط مواضع محدّدة وترك البقية عند الصفر، وهو أمر مفيد لجداول البحث الفارغة في معظمها.

الشيء الوحيد الذي لا يمكنك فعله هو إسناد مصفوفة بعد تعريفها:

int a[3] = {1, 2, 3};
int b[3];
b = a;                    // خطأ: المصفوفة غير قابلة للإسناد
memcpy(b, a, sizeof a);   // هكذا تنسخ واحدة

الفهرسة تبدأ من الصفر

العنصر الأول هو arr[0] والأخير هو arr[n-1]. ولا وجود لـ arr[n].

#include <stdio.h>

int main(void) {
    int scores[5] = {88, 92, 75, 60, 100};

    printf("first  scores[0] = %d\n", scores[0]);
    printf("third  scores[2] = %d\n", scores[2]);
    printf("last   scores[4] = %d\n", scores[4]);

    scores[1] = 95;                       // الكتابة في عنصر
    printf("after update, scores[1] = %d\n", scores[1]);

    printf("\naddresses (note the even spacing):\n");
    for (int i = 0; i < 5; i++) {
        printf("  scores[%d] at %p\n", i, (void *)&scores[i]);
    }

    return 0;
}

شغّل تلك الحلقة الأخيرة وانظر إلى العناوين: كل عنوان يبعد عن سابقه بمقدار sizeof(int) بايت بالضبط. العناصر موضوعة فعلًا طرفًا إلى طرف:

 index      0         1         2         3         4
         +--------+--------+--------+--------+--------+
 value   |   88   |   95   |   75   |   60   |  100   |
         +--------+--------+--------+--------+--------+
 offset   +0       +4       +8       +12      +16      bytes
          ^
          &scores[0], which is also what `scores` decays to

الفهرسة من الصفر ليست اختيارًا اعتباطيًا - فهي تجعل الفهرس إزاحة من البداية، وهو بالضبط ما يحتاجه حساب العناوين. يُعرَّف scores[i] بأنه *(scores + i)؛ انظر المؤشّرات والمصفوفات.

إيجاد الطول

لا تخزّن C طول المصفوفة في أي مكان أثناء التشغيل، لكن المترجم يعرفه، وsizeof يمنحك الوصول إليه:

#include <stdio.h>

int main(void) {
    double prices[] = {4.99, 12.50, 0.99, 7.25};

    printf("total bytes    = %zu\n", sizeof prices);
    printf("bytes per item = %zu\n", sizeof prices[0]);
    printf("length         = %zu\n", sizeof prices / sizeof prices[0]);

    return 0;
}

sizeof(arr) / sizeof(arr[0]) هي الصيغة الاصطلاحية. والقسمة على arr[0] بدلًا من sizeof(double) المكتوب يدويًا تعني أن السطر يستمرّ في العمل إن غيّرت نوع العنصر.

الفخّ: هذا يعمل فقط حيث عُرّفت المصفوفة. مرّر المصفوفة إلى دالة فيصبح الوسيط مؤشّرًا، ويقيس sizeof المؤشّر بدلًا منها - عادةً 8 بايت، فيعطي "طولًا" مقداره 1 أو 2. ولهذا فإن كل دالة في C تأخذ مصفوفة تأخذ معها عددًا أيضًا:

#include <stdio.h>

int sum(const int *arr, int n) {       // يجب تمرير الطول
    int total = 0;
    for (int i = 0; i < n; i++) {
        total += arr[i];
    }
    return total;
}

int main(void) {
    int data[6] = {3, 1, 4, 1, 5, 9};
    int n = sizeof data / sizeof data[0];   // يُحسب هنا، حيث يكون صحيحًا

    printf("length = %d\n", n);
    printf("sum    = %d\n", sum(data, n));

    return 0;
}

المرور على مصفوفة

الشكل القياسي هو حلقة for تبدأ من 0 ما دام i < n:

#include <stdio.h>

int main(void) {
    int temps[7] = {18, 21, 25, 22, 19, 17, 24};
    int n = sizeof temps / sizeof temps[0];

    int total = 0, hottest = temps[0], coldest = temps[0];

    for (int i = 0; i < n; i++) {
        total += temps[i];
        if (temps[i] > hottest) hottest = temps[i];
        if (temps[i] < coldest) coldest = temps[i];
    }

    printf("readings: ");
    for (int i = 0; i < n; i++) printf("%d ", temps[i]);

    printf("\naverage:  %.1f\n", (double)total / n);
    printf("hottest:  %d\n", hottest);
    printf("coldest:  %d\n", coldest);

    return 0;
}

لاحظ i < n، لا i <= n. مع n عنصرًا تكون الفهارس الصالحة من 0 إلى n - 1، فيُنفّذ <= مرورًا إضافيًا ويقرأ ما بعد النهاية. وتهيئة hottest وcoldest من temps[0] بدلًا من 0 هي العادة الأخرى الجديرة بالنسخ - فبدء قيمة عظمى من الصفر ينكسر بصمت مع بيانات كلها سالبة.

تجاوز الحدود سلوك غير معرَّف

هذا هو الجزء من لغة C الذي يفاجئ القادمين من لغات أخرى. لا يوجد فحص للحدود. لا عند الترجمة ولا عند التشغيل. arr[10] على مصفوفة من خمسة عناصر ليس خطأً - بل هو حساب عنوان يجريه المترجم دون تعليق.

int arr[5] = {1, 2, 3, 4, 5};
arr[7] = 99;     // يكتب 8 بايت بعد نهاية المصفوفة
int x = arr[-1]; // يقرأ قبل البداية

ما يحدث بعد ذلك هو سلوك غير معرَّف، وأعراضه متنوّعة بشكل غير مفيد:

• يبدو وكأنه يعمل، لأن الذاكرة التي أصابها كانت غير مستخدمة؛
• يتغيّر متغيّر آخر دون سبب ظاهر؛
• ينهار البرنامج بـ خطأ تجزئة، ربما بعد وقت طويل؛
• يختلف السلوك بين -O0 و-O2.

"يبدو وكأنه يعمل" هو الخطر الأكبر، لأنه يعني أن العلّة تُشحن مع المنتج. ثلاثة خطوط دفاع:

1. كرّر بـ i < n. معظم التجاوزات أخطاء انزياح بمقدار واحد في شرط حلقة.
2. تحقّق من الفهارس القادمة من الإدخال.

#include <stdio.h>

int main(void) {
    int arr[5] = {10, 20, 30, 40, 50};
    int n = 5;

    int requests[4] = {2, 5, -1, 4};    // اثنان منها خارج المدى

    for (int i = 0; i < 4; i++) {
        int idx = requests[i];
        if (idx >= 0 && idx < n) {
            printf("arr[%d] = %d\n", idx, arr[idx]);
        } else {
            printf("index %d rejected (valid range is 0..%d)\n", idx, n - 1);
        }
    }

    return 0;
}

3. ابنِ بأداة تعقيم أثناء التطوير. يحوّل gcc -fsanitize=address -g prog.c معظم التجاوزات إلى تقرير فوري يسمّي الملف والسطر والمصفوفة المعنيّة.

مصفوفات من أنواع أخرى

الصياغة نفسها تعمل مع أي نوع عنصر، بما في ذلك البنى:

#include <stdio.h>

typedef struct {
    const char *name;
    int         score;
} Player;

int main(void) {
    Player players[3] = {
        {"Ada",   91},
        {"Grace", 78},
        {"Ken",   85}
    };
    int n = sizeof players / sizeof players[0];

    for (int i = 0; i < n; i++) {
        printf("%-6s %3d\n", players[i].name, players[i].score);
    }

    // مصفوفة من char تكون سلسلة نصية عندما تنتهي بـ '\0'
    char word[6] = "hello";        // 5 محارف زائد محرف الإنهاء
    printf("\nword = %s (%zu bytes of storage)\n", word, sizeof word);

    return 0;
}

سطر char word[6] = "hello"; يستحق وقفة: السلسلة النصية في C ليست سوى مصفوفة char آخر بايت ذي معنى فيها هو '\0'. ذلك المحرف المُنهي هو سبب حاجة المصفوفة إلى ستة مواضع لخمسة حروف.

المصفوفات متغيّرة الطول، باختصار

يسمح C99 بمصفوفة حجمها قيمة تُحسب أثناء التشغيل:

int n = get_count();
int buffer[n];        // مصفوفة متغيّرة الطول

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

عندما يكون الحجم مجهولًا فعلًا حتى وقت التشغيل، خصّص الذاكرة بدلًا من ذلك:

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

int main(void) {
    int n = 6;                              // افترض أن هذا جاء من الإدخال

    int *arr = malloc(n * sizeof *arr);     // الكومة، لا المكدّس
    if (arr == NULL) {
        return 1;
    }

    for (int i = 0; i < n; i++) {
        arr[i] = (i + 1) * (i + 1);
    }
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);              // الفهرسة تعمل بالطريقة نفسها تمامًا
    }
    printf("\n");

    free(arr);
    return 0;
}

لاحظ أن arr[i] تُقرأ بالشكل نفسه سواء كانت arr مصفوفة أو مؤشّرًا إلى ذاكرة مخصّصة - فصياغة الفهرسة لا تأبه بذلك. التفاصيل الكاملة في الذاكرة الديناميكية.