טיפוסי נתונים ב-C++: int, double, char, bool ועוד

למה טיפוסים חשובים ב-C++

כשמצהירים על ערך עם טיפוס מפורש כמו int age = 30;, הטיפוס הוא לא רק תווית: הוא אומר למהדר כמה בתים לשריין, איך לפרש את הבתים האלה ואילו פעולות חוקיות. בחירה לא נכונה של טיפוס עלולה לגרום לאובדן דיוק שקט, לגלישה או ל-undefined behavior.

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

הטיפוסים הבסיסיים

הנה אחד מכל טיפוס מרכזי בתוכנית אחת. שימו לב לסיומות הליטרלים (L, f, u) ולגרשיים הבודדים סביב char:

#include <iostream>
using namespace std;

int main() {
    int    count = 42;          // מספר שלם, לרוב 32 ביט
    long long big = 9000000000LL; // מספר שלם רחב יותר, הסיומת LL
    double price = 19.99;       // עשרוני של 64 ביט (ברירת המחדל לעשרוניים)
    float  ratio = 0.5f;        // עשרוני של 32 ביט, שימו לב ל-f
    char   grade = 'A';         // תו בודד, בגרשיים בודדים
    bool   passed = true;       // רק true או false

    cout << count << " " << big << "\n";
    cout << price << " " << ratio << "\n";
    cout << grade << " " << passed << "\n"; // bool מודפס כ-1 / 0
}

bool מודפס כברירת מחדל כ-1 או 0, לא כ-true/false. char משתמש בגרשיים בודדים: 'A' הוא תו אחד, בעוד ש-"A" (במירכאות כפולות) הוא ליטרל מחרוזת, טיפוס שונה לגמרי. שתי הטעויות האלה נפוצות מאוד בהתחלה.

הגדלים לא קבועים

זו ההפתעה הגדולה ביותר למי שמגיע משפות כמו Java. התקן של C++ מבטיח רק גדלים מינימליים וסדר יחסי (short ≤ int ≤ long ≤ long long). הגודל בפועל תלוי במהדר ובפלטפורמה. תמיד בדקו עם sizeof:

#include <iostream>
using namespace std;

int main() {
    cout << "char:      " << sizeof(char)      << " byte\n";  // תמיד 1
    cout << "short:     " << sizeof(short)     << " bytes\n";
    cout << "int:       " << sizeof(int)       << " bytes\n";
    cout << "long:      " << sizeof(long)      << " bytes\n";
    cout << "long long: " << sizeof(long long) << " bytes\n";
    cout << "double:    " << sizeof(double)    << " bytes\n";
}

בבנייה טיפוסית של Linux ב-64 ביט תראו int = 4, long = 8. אבל ב-Windows של 64 ביט, long הוא רק 4 בתים. פער הניידות הזה הוא בדיוק הסיבה לא לכתוב קוד שמניח ש-long הוא 64 ביט.

כשצריך רוחב מדויק, השתמשו בטיפוסים השלמים ברוחב קבוע מ-<cstdint>:

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

int main() {
    int8_t   a = -120;          // בדיוק 8 ביט, signed
    uint16_t b = 65000;         // בדיוק 16 ביט, unsigned
    int32_t  c = 2000000000;    // בדיוק 32 ביט
    int64_t  d = 9000000000LL;  // בדיוק 64 ביט, בכל פלטפורמה

    cout << (int)a << " " << b << " " << c << " " << d << "\n";
}

השתמשו ב-int32_t/int64_t לפורמטים של קבצים, לפרוטוקולי רשת, או לכל דבר שחייב להתנהג זהה בכל המכונות. שימו לב להמרה (int)a: הזרמה של טיפוס של 8 ביט מדפיסה אותו כתו ולא כמספר, ולכן ממירים אותו קודם.

signed מול unsigned

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

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

int main() {
    unsigned int u = 0;
    u = u - 1;          // התוצאה אינה -1
    cout << u << "\n";  // מתגלגל ל-4294967295 (המקסימום של unsigned int)

    cout << "int max:  " << INT_MAX << "\n";
    cout << "uint max: " << UINT_MAX << "\n";
}

חיסור מ-0 שהוא unsigned מתגלגל למספר חיובי ענק במקום להפוך לשלילי. זה פוגע באנשים כל הזמן, במיוחד עם size_t (טיפוס unsigned) שמוחזר מ-.size():

vector<int> v = {1, 2, 3};
// סכנה: v.size() הוא unsigned. אם v ריק, v.size() - 1 מתגלגל
// למספר עצום והלולאה רצה כמעט לנצח.
for (size_t i = 0; i <= v.size() - 1; i++) { /* ... */ }

העדיפו i < v.size() (אף פעם לא <= size() - 1), או עקפו את כל הבעיה עם לולאת for מבוססת טווח.

גלישה של מספרים שלמים היא undefined behavior

בניגוד לגלגול של unsigned (שמוגדר היטב), גלישה של מספר שלם signed היא undefined behavior ב-C++. המהדר רשאי לעשות כל דבר: להחזיר זבל, להסיר את הבדיקה באופטימיזציה, או לקרוס:

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

int main() {
    int maxInt = INT_MAX;            // 2147483647
    cout << maxInt << "\n";
    cout << maxInt + 1 << "\n";      // UNDEFINED BEHAVIOR: לרוב מתגלגל לשלילי

    long long safe = (long long)maxInt + 1; // מרחיבים לפני החיבור
    cout << safe << "\n";            // 2147483648, נכון
}

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

בחירת הטיפוס הנכון

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

כמה מלכודות שכדאי לזכור. ל-float יש רק כ-7 ספרות עשרוניות משמעותיות, ולכן 0.1f + 0.2f אינו בדיוק 0.3: העדיפו double אלא אם באמת צריך לחסוך בזיכרון. ו-char יכול להיות signed או unsigned בהתאם לפלטפורמה, אז אם אתם מבצעים חישובים על בתים גולמיים, כתבו במפורש signed char או unsigned char.

הבא בתור: מילת המפתח auto

לכתוב את הטיפוס בכל פעם זה מייגע, ולפעמים הטיפוס ארוך או קשה לניסוח. C++ מאפשרת למהדר להסיק אותו בשבילכם עם מילת המפתח auto: auto x = 42; הופך את x ל-int, ו-auto it = v.begin(); חוסך לכם להקליד טיפוס איטרטור ארוך. העמוד הבא מסביר מתי auto הופכת קוד לברור יותר ומתי היא מסתירה יותר מדי.