typedef ב-C: שמות לטיפוסים, הניב typedef struct ומתי לוותר עליו

typedef עושה דבר קטן אחד: הוא נותן לטיפוס שכבר קיים שם נוסף. לא נוצר טיפוס חדש, לא מוקצה זיכרון, ושום דבר באופן שבו הערך מתנהג לא משתנה. זה כלי לתת שמות, וב-C, שבה שמות הטיפוסים המובנים ארוכים (unsigned long long, struct Employee, void (*)(int)), לשם טוב יש ערך רב.

הצורה הבסיסית

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

unsigned long  count;    // מצהיר על משתנה בשם count
typedef unsigned long  ulong;   // מצהיר על טיפוס בשם ulong

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

#include <stdio.h>

typedef unsigned long ulong;
typedef double Celsius;
typedef double Fahrenheit;

Fahrenheit to_f(Celsius c) {
    return c * 9.0 / 5.0 + 32.0;
}

int main(void) {
    ulong big = 4000000000UL;
    Celsius body = 37.0;

    printf("%lu\n", big);
    printf("%.1fC = %.1fF\n", body, to_f(body));
    return 0;
}

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

הניב typedef struct

זו הסיבה שרוב תוכניות ה-C מכילות typedef בכלל. ב-C שם הטיפוס של struct כולל את מילת המפתח:

struct Point { int x; int y; };
struct Point p;              /* המילה "struct" בכל פעם מחדש */

typedef מקצר את זה:

#include <stdio.h>

typedef struct Point {
    int x;
    int y;
} Point;

Point midpoint(Point a, Point b) {
    Point m = {(a.x + b.x) / 2, (a.y + b.y) / 2};
    return m;
}

int main(void) {
    Point a = {0, 0};
    Point b = {10, 6};
    Point m = midpoint(a, b);

    printf("midpoint: (%d, %d)\n", m.x, m.y);
    return 0;
}

קראו את זה עם הכלל מקודם: הסירו את ה-typedef ונשארתם עם struct Point {...} Point;, הצהרה על משתנה בשם Point. החזירו את typedef, ו-Point הופך לשם של טיפוס במקום.

עם תגית או בלעדיה

אפשר להשמיט את התגית לגמרי, ולקבל struct אנונימי עם שם typedef בלבד:

typedef struct {
    int x;
    int y;
} Point;          /* אין "struct Point", יש רק "Point" */

זה מסודר יותר, ולרשומת נתונים פשוטה זה הסגנון הנפוץ. אבל זה נכשל ברגע שה-struct צריך להזכיר את עצמו, כי אי אפשר להשתמש בשם ה-typedef עד שההצהרה שלו מסתיימת:

/* לא מתקמפל: "Node" עוד אינו טיפוס בתוך הסוגריים של עצמו. */
typedef struct {
    int value;
    Node *next;
} Node;

השאירו את התגית וההתייחסות העצמית עובדת, כי אפשר להשתמש ב-struct Node ברגע שהתגית נראתה:

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

typedef struct Node {
    int value;
    struct Node *next;     /* התגית, לא שם ה-typedef */
} Node;

int main(void) {
    Node *head = malloc(sizeof *head);
    Node *second = malloc(sizeof *second);
    if (head == NULL || second == NULL) {
        free(head);
        free(second);
        return 1;
    }

    head->value = 1;
    head->next = second;
    second->value = 2;
    second->next = NULL;

    for (Node *n = head; n != NULL; n = n->next) {
        printf("%d ", n->value);
    }
    printf("\n");

    free(second);
    free(head);
    return 0;
}

הכלל המעשי: השאירו את התגית. היא עולה מילה אחת, היא תואמת את שם ה-typedef כך ששום דבר לא מבלבל, והיא משאירה פתח להתייחסות עצמית ולהצהרות מוקדמות בקבצי header. בעמוד structs ומצביעים תראו למה הצומת המקושר הזה מתפתח.

הצהרות מוקדמות וטיפוסים אטומים

מכיוון שלמצביע ל-struct יש גודל ידוע גם כשהתוכן של ה-struct לא ידוע, קובץ header יכול למסור טיפוס בלי לחשוף את השדות שלו:

/* stack.h */
typedef struct Stack Stack;     /* מוצהר, לא מוגדר */

Stack *stack_create(void);
void   stack_push(Stack *s, int value);
int    stack_pop(Stack *s);
void   stack_destroy(Stack *s);

ה-struct Stack { ... }; המלא נמצא ב-stack.c, ואף אחד מבחוץ לא יכול לגעת בשדות שלו. דפוס הטיפוס האטום (opaque type) הזה הוא הדרך שבה ספריות C אוכפות כימוס, וזה בדיוק מה ש-FILE הוא בספרייה הסטנדרטית: מקבלים FILE * מ-fopen ולא אומרים לכם כלום על מה שבתוכו. ראו טיפול בקבצים.

typedef ל-enums ול-unions

אותו ניב חל על שני הסוגים המורכבים האחרים:

#include <stdio.h>

typedef enum Color {
    RED,
    GREEN,
    BLUE
} Color;

typedef union Number {
    int i;
    float f;
} Number;

int main(void) {
    Color c = GREEN;
    Number n;
    n.i = 42;

    printf("color = %d, number = %d\n", c, n.i);
    return 0;
}

בלי ה-typedef אלה היו enum Color c; ו-union Number n;. ראו את עמוד ה-enums ואת unions כדי להבין מה הם עושים בפועל.

typedef למצביע לפונקציה

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

void (*handler)(int, const char *);        /* משתנה */
void register_cb(void (*cb)(int, const char *));   /* פרמטר */

תנו שם לטיפוס פעם אחת, ושניהם הופכים לקריאים:

#include <stdio.h>

typedef int (*IntBinaryOp)(int, int);

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

int apply(IntBinaryOp op, int a, int b) {
    return op(a, b);
}

int main(void) {
    IntBinaryOp ops[] = {add, mul};
    const char *names[] = {"add", "mul"};

    for (int i = 0; i < 2; i++) {
        printf("%s(3, 4) = %d\n", names[i], apply(ops[i], 3, 4));
    }
    return 0;
}

החילו שוב את כלל הסרת ה-typedef: int (*IntBinaryOp)(int, int); לבד היה מצהיר על משתנה בשם IntBinaryOp שמצביע לפונקציה שמקבלת שני int ומחזירה int. עם typedef, זה הופך לשם הטיפוס. עוד בעמוד מצביעים לפונקציות.

typedef מול #define

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

#define INT_PTR int *
typedef int *int_ptr;

INT_PTR  a, b;    /* מתרחב ל: int *a, b;  ו-b הוא int רגיל! */
int_ptr  c, d;    /* גם c וגם d הם int *          */

#define הוא החלפת טקסט עיוורת שמתבצעת לפני שהקומפיילר רואה את הקוד, ו-typedef הוא הצהרה אמיתית שהקומפיילר מבין, והיא חלה על כל שם ברשימה. השתמשו ב-typedef לטיפוסים, ושמרו את #define לקבועים ולמאקרו.

כש-typedef מזיק

typedefs יכולים גם להסתיר מידע שהקורא צריך. הדוגמה החדה ביותר היא הסתרה של מצביע:

typedef struct Node *NodeRef;    /* הכוכבית נעלמת */

NodeRef n = get_node();

כשמסתכלים על NodeRef n, קורא לא יכול לדעת אם n יכול להיות NULL, אם צריך לשחרר אותו, אם n ועותק שלו חולקים את אותו אובייקט, או אם ניגשים לשדות עם . או עם ->. struct Node *n עונה על כל ארבע השאלות מיד.

הספרייה הסטנדרטית מסכימה: היא עושה typedef ל-struct (FILE) ומשאירה את הכוכבית בנקודת השימוש (FILE *fp). מזה נובעות שתי הנחיות סבירות:

• כן לעשות typedef ל-structs, ל-unions, ל-enums ולמצביעים לפונקציות: הרעש שמוסר לא נושא שום מידע.
• לא לעשות typedef למצביע רק כדי לקצר אותו, ולא לעשות typedef לטיפוס בסיסי כדי להסוות אותו (typedef int Boolean; מזמין מישהו לשמור בו 7. השתמשו במקום זה ב-bool מתוך <stdbool.h>, שמוסבר בערכים בוליאניים).

השמות ברוחב קבוע של הספרייה הסטנדרטית עצמה ב-<stdint.h> (uint32_t, int64_t, size_t) הם כולם typedefs, והם הטיעון הטוב ביותר בעד היכולת הזו: הם אומרים בדיוק מה הם, הם ניידים, ושום דבר לא מוסתר.