المؤشّرات والمصفوفات في لغة C: التحوّل وarr[i] = *(arr+i) وفخّ sizeof

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

ترسم هذه الصفحة الخطّ بدقة.

تحوّل المصفوفة: القاعدة الواحدة وراء كل شيء

في كل تعبير تقريبًا، يُحوَّل اسم المصفوفة تلقائيًا إلى مؤشّر إلى عنصرها الأول. ويُسمّى ذلك التحوّل. فتصبح arr هي &arr[0]، من النوع int *.

#include <stdio.h>

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

    printf("arr      = %p\n", (void *)arr);       // تتحوّل إلى &arr[0]
    printf("&arr[0]  = %p\n", (void *)&arr[0]);   // العنوان نفسه
    printf("*arr     = %d\n", *arr);              // 10، العنصر الأول

    int *p = arr;                                  // لا حاجة إلى & - فالتحوّل يفعلها
    printf("*p       = %d\n", *p);

    return 0;
}

يُطبَع اسم المصفوفة وعنوان عنصرها الأول متطابقين. وذلك هو التحوّل وهو يعمل، وهو سبب إمكان إسناد مصفوفة إلى مؤشّر دون &.

وهناك ثلاثة مواضع بالضبط لا يحدث فيها التحوّل: كمعامل لـ sizeof، وكمعامل لـ &، وعند تهيئة مصفوفة محارف من ثابت نصّي. وفي كل ما عداها، افترض التحوّل.

arr[i] هي حرفيًا *(arr + i)

يعرّف معيار C عامل الفهرسة بدلالة حساب المؤشّرات: فـ a[b] تعني *(a + b). والفهرسة ليست خاصية منفصلة - بل اختصار.

#include <stdio.h>

int main(void) {
    int arr[5] = {1, 2, 3, 4, 5};

    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d   *(arr + %d) = %d\n",
               i, arr[i], i, *(arr + i));
    }

    int *p = arr;
    printf("\np[2] = %d  (a pointer can be subscripted too)\n", p[2]);
    printf("2[arr] = %d  (legal, because addition commutes)\n", 2[arr]);

    return 0;
}

وتتبع ذلك نتيجتان. أولًا، يمكن فهرسة مؤشّر: فـ p[2] هي *(p + 2)، ولهذا تستطيع الدوال التي تستقبل مؤشّرًا أن تستخدم صياغة arr[i] المألوفة. وثانيًا، تُترجَم 2[arr] - فـ *(2 + arr) هو العنوان نفسه الذي تعنيه *(arr + 2). لا يكتب أحد ذلك خارج اختبار، لكنه يحسم مسألة ما إذا كانت الفهرسة "فعلًا" حسابَ مؤشّرات.

تمرير مصفوفة إلى دالة

بسبب التحوّل، لا تستقبل الدالة مصفوفة أبدًا. بل تستقبل مؤشّرًا.

#include <stdio.h>

// هذه التصريحات الثلاثة متطابقة بالنسبة إلى المترجم
int sum_a(int arr[], int n);
int sum_b(int arr[100], int n);   // يُتجاهَل الرقم 100 كليًا
int sum_c(int *arr, int n);

int sum_c(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("n     = %d\n", n);
    printf("sum   = %d\n", sum_c(data, n));

    // تعمل على شريحة أيضًا - فالمؤشّر مجرّد موضع بداية
    printf("tail  = %d\n", sum_c(data + 3, 3));

    return 0;
}

ثلاثة أمور تستحق الاستخراج من ذلك المثال.

الحجم في int arr[100] توثيق، لا أكثر. فالمترجم يعيد كتابة الوسيط إلى int *arr ولا يفحص إطلاقًا أنك مرّرت مئة من أي شيء.

يجب أن يسافر الطول منفصلًا. فلدى الدالة عنوان ولا فكرة لها عن مدى امتداد البيانات. ولهذا تأخذ كل دالة C تقريبًا تستقبل مصفوفة عددًا: memcpy(dst, src, n)، وfread(ptr, size, count, f)، وqsort(base, nmemb, size, cmp). والسلاسل النصية استثناء فقط لأنها تحمل علامة نهايتها الخاصة، وهي '\0'.

تمرير مؤشّر رخيص والبيانات مشتركة. فلا تُنسَخ المصفوفة، ويستطيع بذلك الدالة تعديل عناصر المستدعي - وهو غالبًا ما تريده بالضبط:

#include <stdio.h>

void double_all(int *arr, int n) {
    for (int i = 0; i < n; i++) {
        arr[i] *= 2;
    }
}

void print_all(const int *arr, int n) {   // const: وعد بعدم التعديل
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main(void) {
    int values[5] = {1, 2, 3, 4, 5};

    print_all(values, 5);
    double_all(values, 5);
    print_all(values, 5);      // تغيّرت مصفوفة المستدعي فعلًا

    return 0;
}

ضع على الوسائط للقراءة فقط النوع const int * كما تفعل print_all. فذلك يوثّق القصد ويتيح للمترجم التقاط كتابة عرضية.

فخّ sizeof

إليك الخطأ الذي يوقع بكل مبرمج C مرة. sizeof أحد الموضعين اللذين لا يحدث فيهما التحوّل - فهي تعطي حجم المصفوفة الحقيقي حيث تُعرَّف المصفوفة، وحجم مؤشّر في أي موضع تحوّلت فيه المصفوفة.

#include <stdio.h>

void inspect(int arr[]) {
    printf("inside function: sizeof(arr) = %zu\n", sizeof arr);
    printf("inside function: computed length = %zu  <-- WRONG\n",
           sizeof arr / sizeof arr[0]);
}

int main(void) {
    int data[10] = {0};

    printf("in main: sizeof(data) = %zu\n", sizeof data);
    printf("in main: length = %zu  <-- correct\n",
           sizeof data / sizeof data[0]);

    inspect(data);
    return 0;
}

في main، تكون sizeof data أربعين بايتًا ويُحسَب الطول بعشرة. وداخل inspect، تكون sizeof arr حجم مؤشّر - 8 على جهاز 64 بتًا - ويخرج "الطول" اثنين. تبدو الشيفرة متطابقة وهي خاطئة بهدوء.

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

& مصفوفة ليست النوع نفسه

الموضع الآخر الذي لا يحدث فيه التحوّل هو العامل &. فـ &arr مؤشّر إلى المصفوفة كاملة، لا إلى عنصرها الأول. ويحمل الاثنان العنوان نفسه؛ والفرق هو ما تعنيه "أضف 1".

#include <stdio.h>

int main(void) {
    int arr[5] = {1, 2, 3, 4, 5};

    printf("arr      = %p   arr + 1  = %p\n",
           (void *)arr, (void *)(arr + 1));      // تخطو 4 بايتات (int واحد)
    printf("&arr     = %p   &arr + 1 = %p\n",
           (void *)&arr, (void *)(&arr + 1));    // تخطو 20 بايتًا (المصفوفة)

    return 0;
}

عنوان بداية واحد وخطوة مختلفة. فـ arr من النوع int * وتخطو بعنصر واحد؛ و&arr من النوع int (*)[5] وتخطو بالمصفوفة كاملة. وهذه هي الآلية التي تجعل تمرير صفّ من مصفوفة ثنائية الأبعاد ممكنًا، وهو ما تغطّيه المصفوفات متعدّدة الأبعاد.

مؤشّر إلى مصفوفة مقابل مصفوفة مؤشّرات

تصريحان يبدوان متشابهين ويعنيان شيئين متضادّين:

int *p[5];     // array of 5 pointers to int
int (*q)[5];   // pointer to an array of 5 ints

أولوية [] أعلى من *، فتُحلَّل int *p[5] بمعنى "p مصفوفة، من مؤشّرات". أما الأقواس في int (*q)[5] فتجبر * على الارتباط أولًا: "q مؤشّر، إلى مصفوفة".

int *p[5]                     int (*q)[5]

 p[0] -> [ int ]               q -> [ int | int | int | int | int ]
 p[1] -> [ int ]                     one contiguous block of 5
 p[2] -> [ int ]
 p[3] -> [ int ]
 p[4] -> [ int ]
 five separate addresses

ومصفوفة المؤشّرات هي الشائعة، وقد استخدمتها سلفًا: فـ char *argv[] مصفوفة من مؤشّرات إلى سلاسل نصية، واحد لكل وسيط من وسائط سطر الأوامر. وهي أيضًا كيف تحتفظ بقائمة من سلاسل نصية مختلفة الأطوال دون إهدار مساحة.

#include <stdio.h>

int main(void) {
    // مصفوفة مؤشّرات: كل مدخلة تشير إلى سلسلة بطولها الخاص
    const char *days[] = {"Monday", "Tuesday", "Wednesday"};
    int n = sizeof days / sizeof days[0];

    for (int i = 0; i < n; i++) {
        printf("%d: %s\n", i, days[i]);
    }

    // مؤشّر إلى مصفوفة من 5 أعداد int
    int block[5] = {1, 2, 3, 4, 5};
    int (*q)[5] = &block;

    printf("via q: %d %d\n", (*q)[0], (*q)[4]);
    printf("sizeof(*q) = %zu bytes (the whole array)\n", sizeof *q);

    return 0;
}

لاحظ (*q)[0]: راجِع المؤشّر لتحصل على المصفوفة، ثم افهرسها. والأقواس مطلوبة مجددًا، لسبب الأولوية نفسه.

أين تختلف المصفوفات والمؤشّرات فعلًا

احفظ هذا الجدول القصير فيزول اللبس:

اسم المصفوفة ليس متغيّرًا يحمل عنوانًا - بل هو التخزين، ويُحسَب العنوان عند الطلب. ولهذا لا تستطيع الإسناد إليه.