פונקציות ב-C: הצהרה, קריאה והחזרת ערכים

למה פונקציות

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

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

#include <stdio.h>

int square(int n) {
    return n * n;
}

int main(void) {
    printf("%d\n", square(4));
    printf("%d\n", square(9));
    printf("%d\n", square(square(2)));
    return 0;
}

את square כותבים פעם אחת וקוראים לה שלוש פעמים, כולל פעם אחת על התוצאה של עצמה. בעצם כבר קראתם לפונקציות: printf היא אחת, וגם main.

המבנה של פונקציה

returnType name(parameterList) {
    // גוף
    return value;
}

ארבעה חלקים:

• טיפוס ההחזרה: הטיפוס של הערך שהפונקציה מחזירה. int, double, char, טיפוס מצביע, או void במשמעות "כלום".
• שם: כפוף לאותם כללים של שם משתנה, וצריך לומר מה הפונקציה עושה או מפיקה.
• רשימת הפרמטרים: הקלטים, לכל אחד טיפוס משלו, מופרדים בפסיקים. (void) פירושו שהיא לא מקבלת אף אחד.
• גוף: הפקודות, בתוך סוגריים מסולסלים, שמסתיימות ב-return אלא אם טיפוס ההחזרה הוא void.

#include <stdio.h>

/* מקבלת שני int, מחזירה int אחד */
int add(int a, int b) {
    return a + b;
}

/* לא מקבלת כלום, מחזירה double */
double pi(void) {
    return 3.14159265358979;
}

/* מקבלת int, לא מחזירה כלום */
void printBanner(int width) {
    for (int i = 0; i < width; i++) {
        printf("=");
    }
    printf("\n");
}

int main(void) {
    printBanner(20);
    printf("2 + 3 = %d\n", add(2, 3));
    printf("pi     = %f\n", pi());
    printBanner(20);
    return 0;
}

שימו לב ש-pi() עדיין צריכה את הסוגריים הריקים במקום הקריאה: זה מה שהופך אותה לקריאה ולא סתם לאזכור של השם. ו-printBanner(20); היא פקודה בפני עצמה, כי היא לא מפיקה ערך לשימוש.

כתבו (void), לא (), עבור פונקציה בלי פרמטרים. ב-C שתי הצורות האלה אומרות דברים שונים, ו-() היא המתירנית. עוד על זה בהמשך.

קריאה והחזרה

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

#include <stdio.h>

int larger(int a, int b) {
    if (a > b) {
        return a;      /* יוצא מהפונקציה מיד */
    }
    return b;
}

int main(void) {
    int x = larger(17, 42);
    printf("larger(17, 42) = %d\n", x);
    printf("nested: %d\n", larger(larger(3, 9), 5));
    return 0;
}

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

לפונקציה יכולות להיות כמה פקודות return. בכל קריאה היא תבצע רק אחת מהן.

פונקציות void

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

#include <stdio.h>

void printTable(int n, int upTo) {
    for (int i = 1; i <= upTo; i++) {
        printf("%d x %d = %d\n", n, i, n * i);
    }
}

void warn(const char *message, int enabled) {
    if (!enabled) {
        return;            /* return ריק: פשוט יוצאים מוקדם */
    }
    printf("WARNING: %s\n", message);
}

int main(void) {
    printTable(7, 5);
    warn("low disk space", 1);
    warn("this one is suppressed", 0);
    return 0;
}

בתוך פונקציית void, return; בלי ערך יוצא מוקדם. return someValue; שם הוא שגיאת קומפילציה, וכך גם שימוש בקריאה בתוך ביטוי: int x = printTable(7, 5); לא יתקמפל, וזו מערכת הטיפוסים שעושה את העבודה שלה.

פירוק לחלקים: העיקר האמיתי

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

#include <stdio.h>

double average(const int values[], int count) {
    if (count == 0) {
        return 0.0;
    }
    int total = 0;
    for (int i = 0; i < count; i++) {
        total += values[i];
    }
    return (double) total / count;
}

int highest(const int values[], int count) {
    int best = values[0];
    for (int i = 1; i < count; i++) {
        if (values[i] > best) {
            best = values[i];
        }
    }
    return best;
}

int countAbove(const int values[], int count, int threshold) {
    int n = 0;
    for (int i = 0; i < count; i++) {
        if (values[i] > threshold) {
            n++;
        }
    }
    return n;
}

int main(void) {
    int scores[] = {88, 92, 75, 60, 100, 47, 83};
    int n = sizeof(scores) / sizeof(scores[0]);

    double avg = average(scores, n);

    printf("Count:            %d\n", n);
    printf("Average:          %.2f\n", avg);
    printf("Highest:          %d\n", highest(scores, n));
    printf("Above average:    %d\n", countAbove(scores, n, (int) avg));
    return 0;
}

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

שלושה כללי אצבע לחלוקת עבודה לפונקציות:

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

פונקציות שקוראות לפונקציות

פונקציה יכולה לקרוא לכל פונקציה שכבר הוצהרה, כולל כאלה שכתבתם בעצמכם:

#include <stdio.h>

int isEven(int n) {
    return n % 2 == 0;
}

int sumEvens(const int a[], int n) {
    int total = 0;
    for (int i = 0; i < n; i++) {
        if (isEven(a[i])) {
            total += a[i];
        }
    }
    return total;
}

void report(const int a[], int n) {
    printf("Sum of even values: %d\n", sumEvens(a, n));
}

int main(void) {
    int data[] = {3, 8, 12, 5, 7, 20};
    report(data, sizeof(data) / sizeof(data[0]));
    return 0;
}

main קוראת ל-report, שקוראת ל-sumEvens, שקוראת ל-isEven בתוך לולאה. כל קריאה מקבלת סט חדש משלה של משתנים מקומיים, שנערם מעל אלה של הקוראת, והם נזרקים כשהיא חוזרת.

ההגדרות למעלה מסודרות לפי תלות: isEven לפני sumEvens לפני report, כי C דורשת שפונקציה תוצהר לפני שקוראים לה. קראו לפונקציה שמופיעה בהמשך הקובץ והקומפיילר יתלונן על הצהרה מובלעת. הפתרון הכללי הוא אב טיפוס (prototype) בראש הקובץ, שמאפשר לסדר את ההגדרות איך שרוצים. גם פונקציה שקוראת לעצמה היא חוקית ושימושית: זו רקורסיה.

גם main היא פונקציה

main היא פונקציה רגילה שסביבת הריצה קוראת לה בשבילכם. טיפוס ההחזרה int שלה הוא קוד היציאה של התוכנית: 0 פירושו הצלחה, ערך שונה מאפס פירושו כישלון, וסקריפטים של shell וכלי build קוראים אותו.

int main(void) {
    /* ... */
    return 0;
}

מאז C99, הגעה לסוף main בלי return מחזירה 0 באופן מובלע, כלל מיוחד שחל רק על main. כל פונקציה אחרת שאינה void ומסתיימת בלי להחזיר ערך גורמת להתנהגות לא מוגדרת כשהקוראת משתמשת בתוצאה.

הצורה התקנית השנייה היא int main(int argc, char *argv[]), שמקבלת ארגומנטים משורת הפקודה. שתיהן נכונות; void main() לא נכונה, לא משנה מה אומרים מדריכים ישנים.

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

• לשכוח return בפונקציה שאינה void. הקוראת קוראת אז ערך זבל. gcc -Wall מזהיר על כך.
• להצהיר בתוך הגוף על משתנה עם אותו שם כמו פרמטר. הוא מסתיר את הפרמטר, וההשמה שהתכוונתם לעשות לקלט הולכת לאיבוד.
• לצפות שפונקציה תשנה את הארגומנטים שלה. C מעבירה הכול by value, כך שפונקציה מקבלת עותקים. void reset(int x) { x = 0; } לא משנה כלום במקום הקריאה, וזה הנושא של העמוד הבא.
• להשמיט את הסוגריים בקריאה. printBanner; הוא ביטוי חוקי שמחשב את הכתובת של הפונקציה וזורק אותה. הוא מתקמפל, לא עושה כלום, ו--Wall מסמן אותו.
• לכתוב () במקום (void). חוקי, אבל זה מכבה את בדיקת הארגומנטים בדיאלקטים ישנים של C.