מצביעים לפונקציות ב-C: תחביר, callbacks ו-qsort

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

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

תחביר ההצהרה

קחו פונקציה רגילה:

int add(int a, int b);

כדי להצהיר על מצביע שיכול להחזיק את הכתובת שלה, החליפו את השם ב-(*name):

int (*op)(int, int);

קראו את זה מבפנים החוצה: op הוא מצביע, לפונקציה, שמקבלת (int, int), ומחזירה int.

הסוגריים הם לא קישוט. בלעדיהם, ה-* נקשר לטיפוס ההחזרה:

int (*f)(int);   // מצביע לפונקציה שמקבלת int ומחזירה int
int *g(int);     // פונקציה שמקבלת int ומחזירה int*, משהו אחר לגמרי

והנה זה עובד מקצה לקצה:

#include <stdio.h>

int add(int a, int b)      { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }

int main(void) {
    int (*op)(int, int);        // הצהרה

    op = add;                   // השמה (אין צורך ב-&)
    printf("add:      %d\n", op(10, 3));

    op = subtract;              // להצביע למקום אחר
    printf("subtract: %d\n", op(10, 3));

    op = &multiply;             // ה-& מותר אבל מיותר
    printf("multiply: %d\n", (*op)(10, 3));   // וכך גם צורת הקריאה הזו

    printf("\nthe function itself lives at %p\n", (void *)(void (*)(void))add);
    return 0;
}

שתי צורות הקריאה עובדות כי שם של פונקציה מומר אוטומטית למצביע. כתבו op(10, 3); הכתיב (*op)(10, 3) הוא שריד מהעבר.

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

typedef הופך את זה לקריא

תחביר ההצהרה מסתבך מהר, ו-typedef הוא התרופה הסטנדרטית:

#include <stdio.h>

typedef int (*BinaryOp)(int, int);   // BinaryOp = מצביע ל-int(int,int)

int add(int a, int b)      { return a + b; }
int multiply(int a, int b) { return a * b; }

// עכשיו פונקציה שמקבלת פונקציה נקראת כמו כל הצהרה אחרת
int apply(BinaryOp op, int x, int y) {
    return op(x, y);
}

int main(void) {
    BinaryOp op = add;
    printf("apply(add, 4, 5)      = %d\n", apply(op, 4, 5));
    printf("apply(multiply, 4, 5) = %d\n", apply(multiply, 4, 5));
    return 0;
}

השוו את int apply(BinaryOp op, int x, int y) לצורה הגולמית, int apply(int (*op)(int, int), int x, int y). אותה משמעות; אחת מהן אפשר לקרוא במבט אחד. ראו את העמוד על typedef לכללים הכלליים.

Callbacks: הקוראת מספקת את ההתנהגות

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

#include <stdio.h>

typedef int (*Predicate)(int);

int is_even(int n)     { return n % 2 == 0; }
int is_positive(int n) { return n > 0; }
int is_big(int n)      { return n > 100; }

// פונקציה אחת, כל בדיקה
int count_if(const int *arr, int n, Predicate test) {
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (test(arr[i])) {
            count++;
        }
    }
    return count;
}

int main(void) {
    int data[8] = {-4, 3, 120, 7, -9, 200, 0, 15};
    int n = 8;

    printf("even:     %d\n", count_if(data, n, is_even));
    printf("positive: %d\n", count_if(data, n, is_positive));
    printf("big:      %d\n", count_if(data, n, is_big));

    return 0;
}

בלי מצביעים לפונקציות הייתם כותבים count_even, count_positive ו-count_big: שלושה עותקים של אותה לולאה. איתם, הלולאה נכתבת פעם אחת והבדיקה היא הפרמטר.

התמורה האמיתית: qsort

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

void qsort(void *base, size_t nmemb, size_t size,
           int (*compar)(const void *, const void *));

פונקציית ההשוואה מקבלת שני const void *, כתובות של שני איברים, ומחזירה מספר שלילי אם הראשון ממוין לפני השני, אפס אם הם שווים, וחיובי אם הוא ממוין אחריו.

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

int compare_ints(const void *a, const void *b) {
    int x = *(const int *)a;      // ממירים חזרה לטיפוס האמיתי, ואז קוראים
    int y = *(const int *)b;
    if (x < y) return -1;
    if (x > y) return  1;
    return 0;
}

int compare_desc(const void *a, const void *b) {
    return compare_ints(b, a);    // מחליפים את הארגומנטים כדי להפוך את הסדר
}

int main(void) {
    int data[8] = {42, 7, 19, 3, 88, 1, 55, 23};
    int n = sizeof data / sizeof data[0];

    qsort(data, n, sizeof data[0], compare_ints);
    printf("ascending:  ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);

    qsort(data, n, sizeof data[0], compare_desc);
    printf("\ndescending: ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);
    printf("\n");

    return 0;
}

שני הרגלים לקחת מפונקציית ההשוואה הזו. לעולם אל תכתבו return x - y;: זה נראה מתוחכם, אבל גולש עבור ערכים גדולים או שליליים, מפיק סימן שגוי ומערך ממוין לא נכון. בצעו המרה לפני ה-dereference, לא אחריו: *(const int *)a, כי ל-*a על void * אין מה לקרוא.

אותו מנגנון ממיין structs לפי כל שדה שתרצו:

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

typedef struct {
    char name[20];
    int  score;
} Player;

int by_score(const void *a, const void *b) {
    const Player *p = a, *q = b;
    return (q->score > p->score) - (q->score < p->score);   // הגבוה ביותר קודם
}

int by_name(const void *a, const void *b) {
    const Player *p = a, *q = b;
    return strcmp(p->name, q->name);
}

int main(void) {
    Player players[4] = {
        {"Ada",   91},
        {"Grace", 78},
        {"Linus", 91},
        {"Ken",   85}
    };
    int n = 4;

    qsort(players, n, sizeof players[0], by_score);
    printf("by score:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    qsort(players, n, sizeof players[0], by_name);
    printf("by name:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    return 0;
}

הביטוי (q->score > p->score) - (q->score < p->score) מחזיר בדיוק -1, 0 או 1, בלי חיסור ובלי גלישה. ול-strcmp כבר יש את מוסכמת ההחזרה הנכונה, כך שפונקציית השוואה למחרוזות היא שורה אחת.

טבלאות של מצביעים לפונקציות

מערך של מצביעים לפונקציות הופך שרשרת של if/else לחיפוש בטבלה. כך מפרשים (interpreters) מנתבים opcodes וכך מערכות תפריטים מריצות פקודות.

#include <stdio.h>

typedef double (*Operation)(double, double);

double op_add(double a, double b) { return a + b; }
double op_sub(double a, double b) { return a - b; }
double op_mul(double a, double b) { return a * b; }
double op_div(double a, double b) { return b == 0 ? 0.0 : a / b; }

typedef struct {
    char      symbol;
    Operation fn;
    const char *name;
} Entry;

int main(void) {
    Entry table[] = {
        {'+', op_add, "add"},
        {'-', op_sub, "subtract"},
        {'*', op_mul, "multiply"},
        {'/', op_div, "divide"}
    };
    int n = sizeof table / sizeof table[0];

    double x = 12.0, y = 4.0;

    for (int i = 0; i < n; i++) {
        printf("%.1f %c %.1f = %.2f   (%s)\n",
               x, table[i].symbol, y, table[i].fn(x, y), table[i].name);
    }

    // ניתוב לפי תו, בלי switch
    char wanted = '*';
    for (int i = 0; i < n; i++) {
        if (table[i].symbol == wanted) {
            printf("\ndispatched '%c' -> %.2f\n", wanted, table[i].fn(x, y));
            break;
        }
    }

    return 0;
}

הוספת פעולה היא עכשיו הוספת שורה, לא עריכה של switch. שלבו את זה עם structs ותקבלו את הצורה הסטנדרטית של plugin ב-C: struct של מצביעים לפונקציות הוא מה ש"ממשק" אומר בשפה הזו.

דברים שנושכים

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

מצביע null לפונקציה הוא עדיין מצביע null. אתחלו ל-NULL ובדקו לפני קריאה, בדיוק כמו עם מצביעים לנתונים:

if (handler != NULL) {
    handler(event);
}

ראו מצביעי null כדי להבין למה הבדיקה הזו שווה את המקום שלה.

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

תחביר ההצהרה מקונן. פונקציה שמחזירה מצביע לפונקציה היא int (*get_op(char c))(int, int);. כשאתם מוצאים את עצמכם כותבים את זה, פנו ל-typedef:

typedef int (*BinaryOp)(int, int);
BinaryOp get_op(char c);           // אותו דבר, בצורה קריאה