פרמטרים של פונקציות ב-C: העברה by value, מצביעים ומערכים

פרמטרים וארגומנטים

שתי מילים שמשתמשים בהן לסירוגין, אבל כדאי להפריד ביניהן:

• פרמטר הוא המשתנה בהגדרה של הפונקציה: int n ב-int square(int n).
• ארגומנט הוא הערך שמספקים במקום הקריאה: ה-4 ב-square(4).

קריאה לפונקציה יוצרת את הפרמטרים שלה כמשתנים מקומיים חדשים ומעתיקה לתוכם את הארגומנטים. ההעתקה הזו היא כל הנושא של העמוד הזה.

C מעבירה by value, תמיד

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

#include <stdio.h>

void tryToReset(int x) {
    printf("  inside, before: x = %d\n", x);
    x = 0;
    printf("  inside, after:  x = %d\n", x);
}

int main(void) {
    int value = 42;
    printf("before call: value = %d\n", value);
    tryToReset(value);
    printf("after call:  value = %d\n", value);
    return 0;
}

value הוא עדיין 42. הפונקציה קיבלה עותק בשם x, איפסה את העותק, והעותק נעלם כשהפונקציה חזרה. שינוי שם הפרמטר ל-value לא משנה כלום: השם לא מחבר ביניהם; אלה שני משתנים שונים.

אותו דבר נכון לכל טיפוס: int, double, char, מצביע, ואפילו struct שלם (שמועתק שדה אחרי שדה). אם אתם מגיעים מ-Python, Java או JavaScript, שימו לב שבשפות האלה מעבירים הפניות לאובייקטים by value, ולכן שינוי אובייקט בתוך פונקציה נראה גם מחוץ לה. ב-C זה לא כך: היא מעתיקה את האובייקט עצמו.

העברה by value היא יתרון, לא מגבלה. פונקציה לא יכולה להשחית בטעות את הנתונים של הקוראת, וזה הופך את הקוד להרבה יותר קל להבנה.

הכישלון הקלאסי: swap

ההדגמה הקלאסית היא פונקציה שמנסה להחליף בין שני ערכים:

#include <stdio.h>

void brokenSwap(int a, int b) {
    int tmp = a;
    a = b;
    b = tmp;
}

int main(void) {
    int x = 1, y = 2;
    brokenSwap(x, y);
    printf("x = %d, y = %d   (unchanged!)\n", x, y);
    return 0;
}

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

הדמיית העברה by reference עם מצביעים

כדי לאפשר לפונקציה לשנות משתנה של הקוראת, תנו לה את הכתובת של המשתנה במקום את הערך שלו. הכתובת עצמה מועברת by value, כלומר המצביע מועתק, אבל העותק עדיין מצביע על האובייקט המקורי, ולכן כתיבה דרכו מגיעה לזיכרון של הקוראת.

#include <stdio.h>

void swap(int *a, int *b) {
    int tmp = *a;      /* קריאה דרך המצביע  */
    *a = *b;           /* כתיבה דרך המצביע */
    *b = tmp;
}

int main(void) {
    int x = 1, y = 2;
    printf("before: x = %d, y = %d\n", x, y);
    swap(&x, &y);      /* מעבירים את הכתובות */
    printf("after:  x = %d, y = %d\n", x, y);
    return 0;
}

שלושה פריטי תחביר נושאים את כל הרעיון:

• int *a ברשימת הפרמטרים מצהיר על a בתור "מצביע ל-int".
• &x במקום הקריאה מפיק את הכתובת של x.
• *a בתוך הפונקציה פירושו "ה-int ש-a מצביע עליו": אפשר לקרוא אותו ולהשים לו.

לזה מתכוונים מתכנתי C כשהם אומרים "pass by reference", וכדאי לדייק: זו עדיין העברה by value. המצביע מועתק. השמה ל-a עצמו (a = NULL;) תשנה רק את העותק; השמה ל-*a משנה את המשתנה של הקוראת. העמוד על מצביעים מכסה את המודל במלואו.

המחיר הוא שמקום הקריאה כבר לא אומר לכם אם משתנה יכול להשתנות, וזו בדיוק הסיבה ש-& נדרש. swap(x, y) לא יתקמפל; צריך לכתוב swap(&x, &y), וה-& הזה הוא הסימן הגלוי שהקריאה עשויה לשנות את x.

החזרת כמה תוצאות

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

#include <stdio.h>

/* מחזירה 1 בהצלחה, 0 אם המחלק הוא אפס */
int divide(int a, int b, int *quotient, int *remainder) {
    if (b == 0) {
        return 0;
    }
    *quotient = a / b;
    *remainder = a % b;
    return 1;
}

int main(void) {
    int q, r;

    if (divide(17, 5, &q, &r)) {
        printf("17 / 5 = %d remainder %d\n", q, r);
    }

    if (!divide(17, 0, &q, &r)) {
        printf("cannot divide by zero\n");
    }

    return 0;
}

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

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

מערכים הם סיפור אחר

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

#include <stdio.h>

void doubleAll(int a[], int n) {
    for (int i = 0; i < n; i++) {
        a[i] *= 2;          /* זה מגיע למערך של הקוראת */
    }
}

int main(void) {
    int data[] = {1, 2, 3, 4, 5};
    int n = sizeof(data) / sizeof(data[0]);

    doubleAll(data, n);

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

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

int a[] ו-int *a אומרים בדיוק אותו דבר ברשימת פרמטרים. גם int a[100]; הגודל פשוט מתעלמים ממנו. הכתיבה int a[] מתעדת את הכוונה, אבל אל תקראו אותה כ"מערך מועתק".

sizeof בתוך הפונקציה שגוי. זה הבאג:

#include <stdio.h>

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

int main(void) {
    int data[] = {1, 2, 3, 4, 5};
    printf("in main: sizeof(data) = %zu\n", sizeof(data));
    printf("correct length:        %zu\n", sizeof(data) / sizeof(data[0]));
    showSize(data);
    return 0;
}

ב-main, sizeof(data) הוא 20 בתים והאורך יוצא 5. בתוך הפונקציה sizeof(a) הוא הגודל של מצביע, 8 במערכת של 64 ביט, ולכן ה"אורך" הוא 2. הגודל של המערך פשוט לא זמין שם. תמיד העבירו את האורך כפרמטר נפרד. קומפיילרים מודרניים מזהירים על זה עם -Wall.

השתמשו ב-const כשאין כוונה לכתוב. const int a[] אומר שהפונקציה רק קוראת, והקומפיילר אוכף את זה והקורא יכול לסמוך על כך:

int sum(const int a[], int n);        /* מבטיחה לא לשנות את המערך */

גם מחרוזות הן מערכים, אז אותו דבר חל עליהן: void greet(const char *name) היא החתימה הסטנדרטית לפונקציה שקוראת מחרוזת בלי לשנות אותה.

ומה עם העלות?

העברת struct גדול by value מעתיקה כל בית שלו בכל קריאה. עבור struct עם קומץ שדות זה בסדר, ולעתים קרובות אפילו מהיר יותר מהעקיפות שמצביע מוסיף. עבור struct גדול, העבירו מצביע, וסמנו אותו const אם הפונקציה רק קוראת:

struct Config { char name[64]; int flags[32]; double weights[128]; };

void applyConfig(const struct Config *cfg);   /* בלי העתקה של 512 בתים בכל קריאה */

const struct Config *cfg פירושו "מצביע ל-Config שלא אשנה", וכך מקבלים את היעילות של מצביע עם הבטיחות של עותק.

טעויות נפוצות

• לצפות שפרמטר רגיל ישנה את המשתנה של הקוראת. הוא לא יכול. העבירו מצביע.
• לשכוח & במקום הקריאה. swap(x, y) כש-swap מצפה למצביעים היא שגיאת טיפוס: הקומפיילר תופס אותה, אבל רק אם יש אב טיפוס בטווח.
• לשכוח * בתוך הפונקציה. a = b; על שני פרמטרים מסוג מצביע מחליף את העותקים המקומיים, לא את הערכים. מה שרציתם הוא *a = *b;.
• להשתמש ב-sizeof על פרמטר מסוג מערך. תמיד שגוי. העבירו את האורך.
• להחזיר מצביע למשתנה מקומי. המשתנה המקומי מת כשהפונקציה חוזרת, כך שהקוראת מחזיקה מצביע תלוי (dangling pointer), וזו התנהגות לא מוגדרת. החזירו by value, כתבו לתוך buffer שהקוראת סיפקה, או הקצו עם malloc.
• לא לבדוק אם פרמטר מסוג מצביע הוא NULL. פונקציה שמבצעת dereference לכל מה שמעבירים לה תקרוס על ארגומנט null.