קבועים ב-C: const, #define ו-enum

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

למה בכלל לתת שם לערך

השוו את שתי השורות האלה:

double area = 3.14159 * r * r;
double area = PI * r * r;

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

מספרים בלי שם שמפוזרים בקוד נקראים מספרי קסם (magic numbers), והסרתם היא אחד השיפורים הזולים ביותר שאפשר לעשות בתוכנית C.

const

מילת המפתח const מסמנת משתנה כקריא בלבד:

#include <stdio.h>

int main(void) {
    const double PI = 3.14159265358979;
    const int MAX_USERS = 100;

    double r = 2.0;
    printf("Area of r=%.1f: %.4f\n", r, PI * r * r);
    printf("Capacity: %d users\n", MAX_USERS);

    /* PI = 3.0;  <- uncomment this line and the program will not compile */
    return 0;
}

הוציאו את ההשמה מההערה והקומפיילר מסרב: assignment of read-only variable 'PI'. השגיאה הזו בזמן הבנייה היא כל העניין.

משתנה const הוא משתנה אמיתי. יש לו טיפוס, כך שהקומפיילר בודק איך אתם משתמשים בו. הוא מכבד טווח (scope), כך ש-const בתוך פונקציה לא דולף החוצה. יש לו כתובת, כך שאפשר לקחת אליו מצביע. ודיבאגר יכול להראות לכם את השם והערך שלו.

const חייב להיות מאותחל במקום ההצהרה, ואין הזדמנות שנייה:

const int limit;       /* error (or garbage forever): nothing can assign to it later */
const int limit = 50;  /* correct */

#define

החלופה של קדם-המעבד היא מאקרו:

#include <stdio.h>

#define PI 3.14159265358979
#define MAX_USERS 100
#define GREETING "Welcome to the system"

int main(void) {
    double r = 2.0;
    printf("%s\n", GREETING);
    printf("Area of r=%.1f: %.4f\n", r, PI * r * r);
    printf("Capacity: %d users\n", MAX_USERS);
    return 0;
}

זה לא משתנה. לפני שהקומפיילר רץ, קדם-המעבד מחליף כל מופע של PI בקוד המקור בתווים 3.14159265358979. הקומפיילר אף פעם לא רואה את השם בכלל, וזו בדיוק הסיבה של-#define אין טיפוס והוא לא יכול להופיע בדיבאגר.

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

#define MAX_USERS 100;        /* note the semicolon */

int limit = MAX_USERS + 1;    /* expands to: int limit = 100; + 1;  -> error */

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

לפי המוסכמה, מאקרו נכתבים ב-UPPER_CASE; משתני const בדרך כלל הולכים באותה דרך כשהם מייצגים את אותו רעיון.

קבועי enum

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

#include <stdio.h>

enum { MAX_USERS = 100, BUFFER_SIZE = 256 };

enum Weekday { MON, TUE, WED, THU, FRI };

int main(void) {
    char buffer[BUFFER_SIZE];   /* a genuine compile-time constant */

    printf("buffer holds %zu bytes\n", sizeof(buffer));
    printf("MAX_USERS = %d\n", MAX_USERS);

    enum Weekday today = WED;
    printf("MON=%d TUE=%d WED=%d, today=%d\n", MON, TUE, WED, today);
    return 0;
}

הערכים מתחילים ב-0 וגדלים באחד אלא אם משימים להם ערך, כך ש-MON הוא 0 ו-FRI הוא 4. enum { ... } אנונימי הוא ניב נפוץ לקבועים שלמים פשוטים.

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

במה להשתמש

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

המקום היחיד שבו זה באמת נושך הוא גדלי מערכים:

#include <stdio.h>

#define DEFINED_SIZE 5
enum { ENUM_SIZE = 5 };

int global_a[DEFINED_SIZE];   /* fine */
int global_b[ENUM_SIZE];      /* fine */

int main(void) {
    const int const_size = 5;
    int local[const_size];    /* C99 variable-length array - works here... */

    for (int i = 0; i < const_size; i++) local[i] = i * i;
    printf("local[4] = %d\n", local[4]);
    printf("globals: %zu %zu\n", sizeof(global_a), sizeof(global_b));
    return 0;
}

const int ב-C הוא משתנה לקריאה בלבד, לא ביטוי קבוע בזמן קומפילציה. בתוך פונקציה C99 מקבלת int local[const_size] בכך שהיא הופכת אותו למערך באורך משתנה; בטווח הקובץ, בתוך struct או כתווית case הוא נדחה מיד. enum ו-#define עובדים בכל מקום.

(זה אחד ההבדלים האמיתיים מ-C++, שבה const int הוא ביטוי קבוע. קוד שעובר בין השפות נתקל בזה.)

const עם מצביעים

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

const char *p;          /* p points at chars that must not be modified */
char * const q;         /* q itself cannot be re-pointed; the chars can change */
const char * const r;   /* neither the pointer nor the chars can change */

#include <stdio.h>

int main(void) {
    char text[] = "hello";

    const char *p = text;
    /* *p = 'H';  <- error: the data is const through p */
    p = "world";  /* but re-pointing p is fine */
    printf("p now points at: %s\n", p);

    char * const q = text;
    q[0] = 'H';   /* modifying the data through q is fine */
    /* q = "world";  <- error: q itself is const */
    printf("text is now: %s\n", text);
    return 0;
}

הצורה const char * היא זו שתכתבו הכי הרבה, כי זה הטיפוס הנכון לפרמטר של פונקציה שקוראת מחרוזת בלי לשנות אותה:

#include <stdio.h>

/* The const promises the caller: this function will not modify your string. */
size_t count_vowels(const char *s) {
    size_t n = 0;
    for (size_t i = 0; s[i] != '\0'; i++) {
        char c = s[i];
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') n++;
    }
    return n;
}

int main(void) {
    printf("vowels in \"programming\": %zu\n", count_vowels("programming"));
    return 0;
}

הוספת const לפרמטר לקריאה בלבד לא עולה כלום ומתעדת את החוזה באופן שהקומפיילר אוכף. כדאי לעשות את זה בכל מקום.

מחרוזות מילוליות הן למעשה const

מלכודת עדינה ש-const קיים כדי לתפוס:

char *s = "hello";   /* legal C, but s points into read-only memory */
s[0] = 'H';          /* undefined behavior - usually a crash */

מחרוזות מילוליות נמצאות באזור לקריאה בלבד של קובץ ההרצה. כתיבה דרך המצביע הזה בדרך כלל גורמת ל-segfault. הצהרה על המצביע כ-const char *s = "hello"; גורמת לקומפיילר לדחות את ההשמה במקום לתת לה לקרוס בזמן ריצה.

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

#include <stdio.h>

int main(void) {
    const char *literal = "hello";   /* read-only, cannot be modified */
    char copy[] = "hello";           /* an array: a private, modifiable copy */

    copy[0] = 'H';
    printf("literal: %s\n", literal);
    printf("copy:    %s\n", copy);
    return 0;
}