מצביעים ומערכים ב-C: דעיכה, arr[i] = *(arr+i) והמלכודת של sizeof

מערכים ומצביעים הם דברים שונים ב-C שמתנהגים אותו דבר רוב הזמן. ה"רוב הזמן" הזה הוא מה שהופך את הנושא לחמקמק: קוד שמתייחס למערך כמו למצביע בדרך כלל עובד, עד היום שבו הוא נוחת באחד משני המקומות שבהם ההבדל חשוב והתשובה שגויה בשקט.

העמוד הזה מותח את הקו בדיוק.

דעיכת מערך: הכלל האחד שמאחורי הכול

כמעט בכל ביטוי, שם של מערך מומר אוטומטית למצביע לאיבר הראשון שלו. לזה קוראים דעיכה (decay). 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 ואף פעם לא בודק שהעברתם 100 של משהו.

האורך חייב לעבור בנפרד. לפונקציה יש כתובת ואין לה מושג עד כמה רחוק הנתונים משתרעים. זו הסיבה שכמעט כל פונקציית 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 הוא 40 בתים והאורך מחושב ל-10. בתוך inspect, sizeof arr הוא הגודל של מצביע, 8 במחשב של 64 ביט, וה"אורך" יוצא 2. הקוד נראה זהה והוא שגוי בשקט.

הכלל שנובע מזה: חשבו את האורך של מערך רק בטווח שבו המערך הוצהר, והעבירו אותו משם הלאה.

& של מערך הוא לא אותו טיפוס

המקום השני שבו דעיכה לא קורית הוא האופרטור &. &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];     // מערך של 5 מצביעים ל-int
int (*q)[5];   // מצביע למערך של 5 int

ל-[] יש קדימות גבוהה יותר מזו של *, ולכן 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]: מבצעים dereference למצביע כדי לקבל את המערך, ואז ניגשים אליו לפי אינדקס. הסוגריים שוב הכרחיים, מאותה סיבה של קדימות.

איפה מערכים ומצביעים באמת שונים

זכרו את הטבלה הקצרה הזו והבלבול ייעלם:

שם של מערך הוא לא משתנה שמחזיק כתובת: הוא עצמו האחסון, והכתובת מחושבת לפי הצורך. זו הסיבה שאי אפשר להשים לו.