const וקבועים ב-C++: const, constexpr ו-consteval

למה יש קבועים

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

בעוד שמילת המפתח auto נתנה למהדר להסיק את הטיפוס של משתנה, const מגביל את מה שאפשר לעשות עם המשתנה הזה. השתיים משתלבות בחופשיות: const auto limit = 100; הוא int לקריאה בלבד.

הצהרה על ערך const

שימו const לפני הטיפוס. משתנה const חייב להיות מאותחל באותה שורה, כי אין רגע מאוחר יותר שבו מותר לבצע אליו השמה.

#include <iostream>
using namespace std;

int main() {
    const int maxUsers = 100;
    const double pi = 3.14159;

    cout << "Max users: " << maxUsers << "\n";
    cout << "Pi: " << pi << "\n";

    // maxUsers = 200; // שגיאה: השמה למשתנה לקריאה בלבד
    return 0;
}

בטלו את ההערה של ההשמה והתוכנית לא תתהדר: המהדר מדווח "assignment of read-only variable". זו בדיוק הנקודה: הטעות נתפסת עוד לפני שהתוכנית רצה.

הרגל נפוץ של מתחילים שמגיע מ-C הוא #define MAX_USERS 100. הימנעו ממנו. מאקרו הוא החלפת טקסט עיוורת, בלי טיפוס ובלי כבוד לטווחי הכרזה, ולכן אי אפשר לבדוק אותו בדיבאגר והוא מייצר הודעות שגיאה מבלבלות. משתנה const (או constexpr) עובר בדיקת טיפוסים ויש לו טווח כמו לכל משתנה אחר.

const מול constexpr

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

#include <iostream>
using namespace std;

int main() {
    int n = 5;
    const int a = n;          // תקין: ערך מזמן ריצה, רק לקריאה בלבד
    constexpr int b = 10;     // תקין: ידוע בזמן הידור
    // constexpr int c = n;   // שגיאה: n אינו קבוע של זמן הידור

    int grid[b];              // חוקי: גודל מערך חייב להיות קבוע של זמן הידור
    cout << "Array length: " << sizeof(grid) / sizeof(grid[0]) << "\n";
    cout << a << " " << b << "\n";
    return 0;
}

כלל האצבע: השתמשו ב-constexpr בכל פעם שהערך הוא ליטרל קבוע או חישוב שהמהדר יכול לבצע (גודל מערך, אורך באפר, תוויות switch, ארגומנטים של template). השתמשו ב-const רגיל כשהערך נקבע בזמן ריצה אבל לא אמור להשתנות אחר כך, כמו עותק const של ארגומנט של פונקציה.

מאז C++20 יש גם consteval, שמשמש לפונקציות שחייבות לרוץ בזמן הידור:

consteval int square(int x) { return x * x; }
constexpr int area = square(8); // מחושב בזמן ההידור

פונקציית constexpr יכולה לרוץ בזמן הידור; פונקציית consteval תמיד חייבת, אחרת זו שגיאה.

מצביעים ו-const: קוראים מימין לשמאל

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

#include <iostream>
using namespace std;

int main() {
    int x = 1, y = 2;

    const int* p1 = &x;   // מצביע ל-const int: אפשר לכוון מחדש, אי אפשר לערוך את *p1
    p1 = &y;              // OK
    // *p1 = 5;           // שגיאה: *p1 הוא const

    int* const p2 = &x;   // מצביע const ל-int: אפשר לערוך את *p2, אי אפשר לכוון מחדש
    *p2 = 99;             // OK
    // p2 = &y;           // שגיאה: p2 הוא const

    const int* const p3 = &x; // מצביע const ל-const int: שום דבר לא מותר

    cout << *p1 << " " << *p2 << " " << *p3 << "\n";
    return 0;
}

קראו את int* const p2 מימין לשמאל: "p2 is a const pointer to int". קראו את const int* p1 כ-"p1 is a pointer to const int". אם תטעו כאן, תבזבזו זמן אמיתי בבלבול מול שגיאה שאומרת שאי אפשר לשנות משהו שחשבתם שהוא ניתן לשינוי.

מלכודת מעשית: לעולם אל תיקחו את הכתובת של const ותסירו את ה-const בהמרה כדי לשנות את האובייקט שמתחת. זה undefined behavior אם האובייקט המקורי היה באמת const, והמהדר רשאי להניח שהערך לעולם לא משתנה: ה"כתיבה" שלכם עשויה פשוט להתעלם.

הפניות const כפרמטרים של פונקציה

השימוש היומיומי הנפוץ ביותר ב-const הוא העברת אובייקטים גדולים לפי הפניה בלי להעתיק אותם. פרמטר const& חוסך את ההעתקה וגם מבטיח שהפונקציה לא תשנה את הארגומנט של הקורא.

#include <iostream>
#include <string>
using namespace std;

// לא נוצר עותק של המחרוזת, ואי אפשר לשנות אותה בטעות.
void greet(const string& name) {
    // name += "!"; // שגיאה: name הוא const
    cout << "Hello, " << name << "!\n";
}

int main() {
    string user = "Ada";
    greet(user);
    greet("Grace"); // const& נקשר גם לליטרל זמני
    return 0;
}

העברה לפי const& היא הבחירה ברירת המחדל לכל פרמטר שגדול מכמה בתים (מחרוזות, vectors, המחלקות שלכם). שימו לב שהיא גם מאפשרת לפונקציה לקבל ערך זמני כמו "Grace": הפניה רגילה שאינה const לא יכולה להיקשר לערך זמני, ולכן הסרת ה-const כאן הייתה דוחה את הקריאה השנייה.

פונקציות חברות const

כשאתם כותבים מחלקה, סמנו כל מתודה שלא משנה את האובייקט עם const בסוף. זה מה שמאפשר לקרוא למתודה על מופעים const ועל פרמטרים const&; בלי זה, לא תוכלו לקרוא את האובייקט שלכם דרך ידית const.

#include <iostream>
#include <string>
using namespace std;

class Account {
    double balance = 0;
public:
    void deposit(double amount) { balance += amount; } // משנה -> לא const
    double getBalance() const { return balance; }       // קריאה בלבד -> const
};

int main() {
    Account a;
    a.deposit(50);

    const Account& ref = a;        // תצוגה לקריאה בלבד
    cout << ref.getBalance() << "\n"; // עובד רק כי getBalance() היא const
    // ref.deposit(10);            // שגיאה: deposit() אינה const
    return 0;
}

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

הבא בתור: אופרטורים

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