מצביעים ב-C++: אופרטור כתובת, dereference ו-nullptr

משתנה שמחזיק כתובת

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

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

#include <iostream>
using namespace std;

int main() {
    int score = 42;
    int* p = &score;   // p מחזיק את הכתובת של score

    cout << "value of score: " << score << "\n";
    cout << "address of score: " << p << "\n";   // כתובת כלשהי בהקסדצימלי
    cout << "value via pointer: " << *p << "\n"; // גישה דרך המצביע: חזרה ל-42
}

ה-& ב-&score הוא אופרטור הכתובת (address-of): הוא מפיק את המיקום של score. ה-* ב-*p הוא אופרטור הגישה (dereference): הוא עוקב אחרי הכתובת בחזרה אל הערך שנמצא שם.

שני האופרטורים: & ו-*

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

int* p;     // הצהרה: "p הוא מצביע ל-int"
p = &x;     // & = כתובת של: שומרים את הכתובת של x ב-p
int y = *p; // * = גישה: קוראים את הערך ש-p מצביע עליו
*p = 99;    // גישה בצד ההשמה: כותבים דרך המצביע

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

#include <iostream>
using namespace std;

int main() {
    int health = 100;
    int* hp = &health;

    *hp = 80;            // כותבים דרך המצביע
    cout << health << "\n";   // 80: המקורי השתנה

    *hp -= 30;
    cout << health << "\n";   // 50
}

שימו לב שלא נגעתם ב-health בשמו אחרי השורה הראשונה, ובכל זאת הערך שלו המשיך להשתנות. זו כל הנקודה: hp הוא כינוי לאותו אחסון. הריווח (int* p, int *p, int*p) הוא קוסמטי וזהה מבחינת הקומפיילר, והמדריך הזה משתמש ב-int* p.

nullptr: הצבעה על כלום

מצביע שלא מצביע לשום מקום צריך לקבל את הערך nullptr (C++11). זו דרך ברורה ובטוחה מבחינת טיפוסים לומר "אין יעד עדיין", והיא נותנת לכם משהו לבדוק מולו לפני הגישה.

#include <iostream>
using namespace std;

int* findEven(int& a, int& b) {
    if (a % 2 == 0) return &a;
    if (b % 2 == 0) return &b;
    return nullptr;          // שום דבר לא התאים
}

int main() {
    int x = 7, y = 4;
    int* result = findEven(x, y);

    if (result) {            // בדיקת אמת: לא null
        cout << "first even: " << *result << "\n";
    } else {
        cout << "no even number\n";
    }
}

העדיפו nullptr על פני המאקרו הישן NULL או 0 חשוף. מכיוון של-nullptr יש טיפוס מצביע אמיתי, הוא אף פעם לא מתפרש בטעות כמספר השלם 0 בבחירת העמסה, באג עדין שהסגנון הישן יכול היה לגרום.

מלכודת: גישה דרך null. קריאה או כתיבה דרך מצביע null (או לא מאותחל) היא התנהגות לא מוגדרת, ובדרך כלל קריסה מיידית:

int* p = nullptr;
cout << *p;   // קריסה: גישה דרך null היא התנהגות לא מוגדרת

הגנו תמיד עם if (p) (או if (p != nullptr)) לפני שאתם ניגשים דרך משהו שעלול להיות null.

מצביעים ומערכים

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

#include <iostream>
using namespace std;

int main() {
    int nums[] = {10, 20, 30, 40};
    int* p = nums;          // מצביע על nums[0]

    cout << *p << "\n";     // 10
    cout << *(p + 1) << "\n"; // 20: האיבר הבא, לא הבית הבא
    cout << p[2] << "\n";   // 30: p[i] הוא פשוט *(p + i)

    for (int* it = nums; it != nums + 4; ++it) {
        cout << *it << " "; // 10 20 30 40
    }
    cout << "\n";
}

p[i] ו-*(p + i) הם ממש אותו ביטוי, והשקילות הזו היא הסיבה שמערכים מתחילים מאינדקס אפס. הבאג הקלאסי כאן הוא מעבר אל מעבר לסוף: nums + 4 הוא סמן תקין של "אחד אחרי הסוף" להשוואה, אבל גישה דרך *(nums + 4) קוראת מחוץ לגבולות. שגיאות של אחד-יותר-מדי עם מצביעים הן גורם מוביל לקריסות ולהשחתה שקטה של נתונים, ולכן הקפידו על תנאי העצירה.

const ומצביעים

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

const int* p;        // מצביע ל-const int: אי אפשר לשנות את *p, אפשר להפנות את p למקום אחר
int* const p = &x;   // מצביע const ל-int: אפשר לשנות את *p, אי אפשר להפנות את p למקום אחר
const int* const p = &x; // שניהם נעולים

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

#include <iostream>
using namespace std;

int sum(const int* data, int n) {   // יכולה לקרוא, לא יכולה לשנות את המערך
    int total = 0;
    for (int i = 0; i < n; ++i) total += data[i];
    return total;
}

int main() {
    int values[] = {3, 6, 9};
    cout << sum(values, 3) << "\n";  // 18
}

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

המלכודת הגדולה: מצביעים תלויים

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

int* makeBad() {
    int local = 5;
    return &local;   // באג: local מת כשהפונקציה חוזרת
}                    // המצביע שהוחזר תלוי עכשיו

הכתובת עדיין מספר תקין, אבל היא מצביעה על משבצת במחסנית שכבר נלקחה בחזרה: קריאה ממנה נותנת זבל או קריסה. אותו דבר קורה אם שומרים מצביע לאובייקט ב-heap שעבר delete, או לאיבר של vector שמאוחר יותר מקצה את עצמו מחדש.

שלושה כללים שומרים עליכם:

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

הבא בתור: הפניות מול מצביעים

מצביעים הם לא הדרך היחידה להתייחס בעקיפין למשתנה אחר. ב-C++ יש גם הפניות (references), שמרגישות דומות אבל לא יכולות להיות null, לא יכולות להיות מופנות מחדש ומשתמשות בתחביר נקי יותר. בהמשך נשים אותן זו לצד זו בעמוד הפניות מול מצביעים, כדי שתדעו בדיוק באיזה כלי להשתמש, ולמה רוב ה-C++ המודרנית מעדיפה הפניות כשאפשר.