מילת המפתח auto ב-C++: הסקת טיפוסים עם דוגמאות

תנו למהדר לבחור את הטיפוס

בעמוד הקודם ראיתם שלכל משתנה ב-C++ יש טיפוס קבוע: int, double, std::string וכן הלאה. לכתוב את הטיפוס ידנית זה בסדר עבור int count = 0;, אבל זה נהיה רועש כשהטיפוסים מתארכים. מילת המפתח auto (מ-C++11 ואילך) נותנת למהדר להסיק את הטיפוס מהערך שמשימים, כך שכותבים את הערך פעם אחת והמהדר משלים את השאר.

#include <iostream>
using namespace std;

int main() {
    auto count = 0;        // int
    auto price = 3.99;     // double
    auto letter = 'A';     // char
    auto greeting = "hi";  // const char*

    cout << count << " " << price << " " << letter << " " << greeting << "\n";
    return 0;
}

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

למה auto שווה את זה

לטיפוסים קצרים וברורים, auto count = 0; ו-int count = 0; קריאים באותה מידה. auto באמת משתלמת עם שמות טיפוסים ארוכים וחוזרים, מהסוג שמקבלים מהמכלים ומהאיטרטורים של הספרייה הסטנדרטית.

השוו את הגרסה המפורטת לגרסה עם auto:

// בלי auto: בפועל הטיפוס נכתב פעמיים
std::vector<std::pair<std::string, int>>::iterator it = scores.begin();

// עם auto: המהדר כבר יודע מה הטיפוס
auto it = scores.begin();

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

הנה זה בתוכנית מלאה:

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

int main() {
    vector<pair<string, int>> scores = {{"Ada", 90}, {"Boris", 85}};

    for (auto it = scores.begin(); it != scores.end(); ++it) {
        cout << it->first << ": " << it->second << "\n";
    }
    return 0;
}

auto בלולאות for מבוססות טווח

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

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

int main() {
    vector<string> names = {"Ada", "Boris", "Rosa"};

    // const auto&: קריאה בלבד, בלי עותק. ברירת המחדל הרגילה לקריאה.
    for (const auto& name : names) {
        cout << name << "\n";
    }
    return 0;
}

שלוש גרסאות שתראו, ומה כל אחת אומרת:

• for (auto x : v): x הוא עותק של כל איבר. זול עבור int, בזבזני עבור אובייקטים גדולים.
• for (auto& x : v): x הוא הפניה; אפשר לשנות את האיברים במקום.
• for (const auto& x : v): x הוא הפניה לקריאה בלבד. השתמשו בזה כשצריך רק לקרוא.

התוכנית הבאה משנה את המכל דרך auto&:

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

int main() {
    vector<int> nums = {1, 2, 3};

    for (auto& n : nums) {
        n *= 10;        // משנה את האיבר האמיתי
    }

    for (const auto& n : nums) {
        cout << n << " ";   // 10 20 30
    }
    cout << "\n";
    return 0;
}

מלכודת: כתבו for (auto n : nums) (בלי &) בלולאה הזו, וה-n *= 10 ישנה בשקט רק את העותק וישאיר את nums ללא שינוי. המהדר לא יזהיר אתכם: הלולאה פשוט לא עושה שום דבר מועיל.

מה auto מסירה

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

#include <iostream>
using namespace std;

int main() {
    const int original = 42;

    auto copy = original;   // הטיפוס הוא int, לא const int
    copy = 100;             // חוקי לגמרי: ה-const הוסר

    cout << original << " " << copy << "\n";  // 42 100
    return 0;
}

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

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

int main() {
    string name = "Ada";

    const auto& ref = name;   // const std::string&: בלי עותק, קריאה בלבד
    cout << ref << " has " << ref.size() << " letters\n";

    // ref = "Boris";         // שגיאה: ref הוא const
    return 0;
}

כלומר auto מסיקה את טיפוס ה_בסיס_; &, const ו-* הם כפתורים שמוסיפים מעליו. auto הוא הטיפוס, const auto& היא הפניה לקריאה בלבד אליו.

טעויות ומלכודות נפוצות

auto חוסכת הקלדה, לא את הצורך להבין טיפוסים. כמה מלכודות תופסות מתחילים:

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

auto x;        // error: declaration of 'auto x' has no initializer
auto y = 0;    // תקין

ליטרלים שלמים הם int, לא double. auto half = 1 / 2; מסיק int ושומר 0, כי 1 / 2 הוא חילוק שלמים עוד לפני ש-auto רואה אותו. הטיפוס נגזר מהערך:

#include <iostream>
using namespace std;

int main() {
    auto wrong = 1 / 2;      // חילוק שלמים -> 0
    auto right = 1.0 / 2;    // double -> 0.5

    cout << wrong << " " << right << "\n";  // 0 0.5
    return 0;
}

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

אל תסתירו את הטיפוס כשהוא חשוב. auto result = compute(); בסדר כשטיפוס ההחזרה של compute ברור מההקשר, אבל אם הקורא צריך לחפש מה result בעצם, כתיבת הטיפוס במפורש יכולה להיות הבחירה הידידותית יותר. auto נועדה לצמצם רעש, לא להסתיר כוונה.

הבא בתור: קבועים ו-const

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