enum ב-C: קבועים עם שמות, מספור אוטומטי והמרה למחרוזת

קוד מלא במספרים חשופים הוא קוד שאף אחד לא יכול לקרוא. if (state == 2) לא אומר לכם כלום; if (state == STATE_RUNNING) אומר לכם הכול. enum הוא הדרך של C לתת שמות ראויים לקבוצה קטנה וקבועה של מספרים שלמים, ובניגוד לערימה של #define, הם מגיעים מקובצים בטיפוס אחד שהקומפיילר מכיר.

הגדרת enum

ההצהרה נותנת שם לתגית ומפרטת את הקבועים (enumerators) בתוך סוגריים מסולסלים:

#include <stdio.h>

enum Color {
    RED,
    GREEN,
    BLUE
};

int main(void) {
    enum Color favorite = GREEN;

    printf("favorite = %d\n", favorite);
    printf("RED=%d GREEN=%d BLUE=%d\n", RED, GREEN, BLUE);
    return 0;
}

שני דברים כדאי לשים לב אליהם מיד. ראשית, המספור מתחיל ב-0 וגדל באחד, כך ש-RED הוא 0, GREEN הוא 1, BLUE הוא 2. שנית, השמות של הקבועים גלויים בכל מקום בטווח העוטף: כותבים GREEN, לא Color.GREEN. הם חיים באותו מרחב שמות כמו המשתנים שלכם, ולכן לפי המוסכמה קוד C כותב אותם באותיות גדולות או מוסיף להם קידומת לפי הטיפוס (COLOR_RED) כדי למנוע התנגשויות.

הדפסת enum משתמשת ב-%d, כי ערך של enum הוא ערך שלם.

ערכים מפורשים

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

#include <stdio.h>

enum HttpStatus {
    HTTP_OK        = 200,
    HTTP_CREATED   = 201,
    HTTP_NOT_FOUND = 404,
    HTTP_ERROR     = 500
};

enum Level {
    LOW = 10,
    MEDIUM,          /* 11 */
    HIGH,            /* 12 */
    CRITICAL = 100,
    EXTREME          /* 101 */
};

int main(void) {
    printf("%d %d %d %d\n", HTTP_OK, HTTP_CREATED, HTTP_NOT_FOUND, HTTP_ERROR);
    printf("%d %d %d %d %d\n", LOW, MEDIUM, HIGH, CRITICAL, EXTREME);
    return 0;
}

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

ניב נפוץ משתמש בזה כדי לשמור את הספירה:

enum Suit {
    CLUBS, DIAMONDS, HEARTS, SPADES,
    SUIT_COUNT           /* automatically 4 - stays correct if you add a suit */
};

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

typedef enum

כמו ב-structs, השם המלא של הטיפוס ב-C הוא enum Color, ו-typedef משמיט את מילת המפתח:

#include <stdio.h>

typedef enum Direction {
    DIR_NORTH,
    DIR_EAST,
    DIR_SOUTH,
    DIR_WEST,
    DIR_COUNT
} Direction;

int main(void) {
    const int dx[DIR_COUNT] = {0, 1, 0, -1};
    const int dy[DIR_COUNT] = {-1, 0, 1, 0};

    int x = 0, y = 0;
    Direction path[] = {DIR_EAST, DIR_EAST, DIR_SOUTH, DIR_WEST};

    for (size_t i = 0; i < sizeof path / sizeof path[0]; i++) {
        x += dx[path[i]];
        y += dy[path[i]];
    }

    printf("ended at (%d, %d)\n", x, y);
    return 0;
}

מכיוון שהקבועים הם מספרים שלמים רגילים שמתחילים ב-0, הם משמשים גם כאינדקסים של מערכים: dx[DIR_EAST] עובד בלי שום המרה. זו התכונה השימושית ביותר של enum שמתחיל מאפס.

enum בתוך switch

השילוב של enum עם switch הוא המקום שבו הטיפוס מתחיל להחזיר את ההשקעה. קמפלו עם -Wall והקומפיילר יגיד לכם כששכחתם case.

#include <stdio.h>

typedef enum {
    STATE_IDLE,
    STATE_RUNNING,
    STATE_PAUSED,
    STATE_STOPPED
} State;

const char *describe(State s) {
    switch (s) {
        case STATE_IDLE:    return "waiting for work";
        case STATE_RUNNING: return "working";
        case STATE_PAUSED:  return "paused by the user";
        case STATE_STOPPED: return "finished";
    }
    return "unknown";
}

int main(void) {
    for (State s = STATE_IDLE; s <= STATE_STOPPED; s++) {
        printf("%d: %s\n", s, describe(s));
    }
    return 0;
}

הוסיפו STATE_FAILED ל-enum ו-GCC מזהיר: enumeration value 'STATE_FAILED' not handled in switch. האזהרה הזו היא הדבר הקרוב ביותר שיש ל-C לבדיקת שלמות, והיא סיבה טובה לכתוב את פקודות ה-switch האלה בלי default:: default משתיק את האזהרה ונותן למצבים חדשים לחמוק בלי טיפול. שימו את ברירת המחדל אחרי ה-switch במקום זאת, כמו ש-describe עושה.

המרת enum למחרוזת

C לא שומרת שמות בזמן ריצה; printf("%s", GREEN) לא יכול לעבוד כי GREEN הוא פשוט 1. שתי תבניות פותרות את זה.

גרסת ה-switch, שהקומפיילר בודק:

#include <stdio.h>

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

const char *color_name(Color c) {
    switch (c) {
        case RED:   return "RED";
        case GREEN: return "GREEN";
        case BLUE:  return "BLUE";
        case COLOR_COUNT: break;
    }
    return "UNKNOWN";
}

int main(void) {
    for (Color c = RED; c < COLOR_COUNT; c++) {
        printf("%d = %s\n", c, color_name(c));
    }
    return 0;
}

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

#include <stdio.h>

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

static const char *COLOR_NAMES[COLOR_COUNT] = {
    [RED]   = "RED",
    [GREEN] = "GREEN",
    [BLUE]  = "BLUE",
};

const char *color_name(Color c) {
    if (c < 0 || c >= COLOR_COUNT) {
        return "UNKNOWN";
    }
    return COLOR_NAMES[c];
}

int main(void) {
    printf("%s %s %s\n", color_name(RED), color_name(GREEN), color_name(BLUE));
    printf("%s\n", color_name((Color)99));
    return 0;
}

האינדקסים הממוענים במערך ([RED] = "RED") לפחות שומרים את השמות מחוברים לתאים שלהם, כך ששינוי סדר ה-enum לא יכול לערבב את המחרוזות בשקט. בדיקת הגבולות חשובה כי שום דבר לא מונע ממי שקורא לפונקציה להעביר ערך מחוץ ל-enum; ראו את הסעיף הבא.

enum אינו אטום

משתנה enum הוא מספר שלם מתחת למכסה המנוע, ו-C לא שומרת על הטווח:

#include <stdio.h>

typedef enum { RED, GREEN, BLUE } Color;

int main(void) {
    Color c = (Color)42;      /* legal; no check at all */
    int n = BLUE;             /* enum to int: implicit and fine */

    printf("c = %d, n = %d\n", c, n);
    printf("RED + GREEN = %d\n", RED + GREEN);
    return 0;
}

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

גודל ואחסון

ב-C17, כל קבוע חייב להיכנס ב-int: enum Huge { BIG = 3000000000 }; הוא הפרה של אילוץ שקומפיילר קפדני (-pedantic-errors) דוחה, למרות ש-gcc ו-clang מקבלים אותו כהרחבה במצב ברירת המחדל שלהם. לקבועים עצמם יש טיפוס int, בעוד שהגודל של טיפוס ה-enum תלוי מימוש (בפועל, int):

#include <stdio.h>

enum Small { A, B, C };
enum Flags { READ = 1, WRITE = 2, EXEC = 4 };

int main(void) {
    printf("sizeof(enum Small) = %zu\n", sizeof(enum Small));
    printf("sizeof(enum Flags) = %zu\n", sizeof(enum Flags));
    printf("sizeof(int)        = %zu\n", sizeof(int));
    return 0;
}

(C23 מסירה את ההגבלה: קבוע יכול לחרוג מהטווח של int, ואפשר אפילו לבחור את הטיפוס הבסיסי עם enum E : unsigned long { ... }. עד שהכלים שלכם יכוונו ל-C23, השאירו את הקבועים בתוך int.)

מכיוון שהבחירה המדויקת תלויה במימוש, לעולם אל תכתבו enum ישירות לקובץ בינארי או לחבילת רשת ותצפו שמכונה אחרת תקרא אותו בחזרה. המירו לטיפוס ברוחב קבוע כמו uint8_t או uint32_t מ-<stdint.h> בנקודת הגבול.

enum מול #define

שניהם נותנים שם למספר. ה-enum בדרך כלל עדיף:

פנו ל-#define כשהקבוע אינו מספר שלם (מחרוזת, float) או כשהוא חייב להיות שמיש לקדם-המעבד עצמו, כמו בקומפילציה מותנית. לקבוצה של מצבים, דגלים או סוגים שלמים קשורים, השתמשו ב-enum.

מוסכמות שמות

enums מתנגשים בקלות כי השמות שלהם יושבים בטווח הרגיל. המוסכמות ששומרות על שפיות בבסיסי קוד C גדולים:

• הוסיפו לכל קבוע קידומת של הטיפוס: COLOR_RED, STATE_IDLE, HTTP_OK. RED בלי קידומת בתוכנית גרפיקה ייפגש בסוף עם ה-RED של מישהו אחר.
• כתבו את הקבועים ב-SHOUT_CASE, כמו שקבועים אחרים נראים.
• תנו לטיפוס שם ביחיד ב-PascalCase או ב-snake_case_t: Color, State או color_t, באופן עקבי בכל הפרויקט.
• הוסיפו זקיף _COUNT בסוף כשתעברו בלולאה או תשתמשו ב-enum כאינדקס.