Structs ב-C++: קיבוץ נתונים קשורים לטיפוס אחד

למה לקבץ נתונים יחד

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

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

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

struct Student {
    string name;
    int age;
    double gpa;
};   // <- אל תשכחו את הנקודה-פסיק אחרי הסוגר המסולסל הסוגר

int main() {
    Student s;          // אובייקט אחד שמחזיק את שלושת החברים
    s.name = "Ada";
    s.age = 19;
    s.gpa = 3.9;

    cout << s.name << " is " << s.age << " (GPA " << s.gpa << ")\n";
}

ניגשים לכל חבר עם אופרטור הנקודה (s.name, s.age). הנקודה-פסיק אחרי ה-} שסוגר הגדרת struct היא חובה: השמטה שלה היא אחת משגיאות הקומפילציה הנפוצות ביותר של מתחילים ב-C++.

אתחול struct

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

#include <iostream>
using namespace std;

struct Point {
    int x;
    int y;
};

int main() {
    Point a{3, 4};        // x = 3, y = 4 (אתחול עם סוגריים, מועדף)
    Point origin{};       // שני החברים מאותחלים לערך 0
    Point b = {10, 20};   // צורת = {} הישנה, אותה תוצאה

    cout << a.x << "," << a.y << "\n";          // 3,4
    cout << origin.x << "," << origin.y << "\n"; // 0,0
    cout << b.x << "," << b.y << "\n";           // 10,20
}

היזהרו מברירת המחדל הריקה: Point p; (בלי סוגריים) משאיר ב-x וב-y ערכי זבל, כי חברים מטיפוסים מובנים לא מאופסים אוטומטית. Point p{}; מאתחל אותם ל-0. העדיפו את הסוגריים. אפשר גם לקבוע ערכי ברירת מחדל ישירות בהגדרה, כך שאפילו Point p; מתחיל נקי:

#include <iostream>
using namespace std;

struct Config {
    int width  = 800;     // ערכי ברירת מחדל לחברים
    int height = 600;
    bool fullscreen = false;
};

int main() {
    Config c;             // משתמש בכל ברירות המחדל
    Config wide{1920};    // width נדרס, השאר שומרים על ברירת המחדל

    cout << c.width << "x" << c.height << "\n";        // 800x600
    cout << wide.width << "x" << wide.height << "\n";  // 1920x600
}

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

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

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

struct Student {
    string name;
    double gpa;
};

// const& חוסך את העתקת ה-string ומבטיח לא לשנות את s
void printStudent(const Student& s) {
    cout << s.name << ": " << s.gpa << "\n";
}

// להחזיר struct זה בסדר: המהדר מבטל את ההעתקה
Student makeStudent(string name, double gpa) {
    return Student{name, gpa};
}

int main() {
    Student top = makeStudent("Grace", 4.0);
    printStudent(top);
}

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

הוספת פונקציות חברות ובנאים

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

#include <iostream>
using namespace std;

struct Rectangle {
    double width;
    double height;

    // בנאי: רץ כשנוצר Rectangle
    Rectangle(double w, double h) : width(w), height(h) {}

    // פונקציה חברה: משתמשת בחברים של האובייקט עצמו
    double area() const {        // const = "אני לא משנה את האובייקט"
        return width * height;
    }
};

int main() {
    Rectangle r(4.0, 5.0);
    cout << "area = " << r.area() << "\n";   // area = 20
}

בתוך פונקציה חברה ניגשים לחברים לפי השם (width, height): הם מתייחסים לעותק של האובייקט הזה. הסימון area() const אומר למהדר שהפונקציה רק קוראת את האובייקט, וכך אפשר לקרוא לה גם על ערכי const Rectangle. בנאים הם נושא בפני עצמו, כולל תחביר רשימת האתחול : width(w), והדף על בנאים נכנס לזה לעומק.

Struct מול class: ההבדל האמיתי

אולי שמעתם ש"structs הם לנתונים, ו-classes הם לאובייקטים". זו מוסכמה, לא כלל של השפה. ב-C++ struct ו-class הם כמעט אותו דבר: ההבדל המובנה היחיד הוא רמת הגישה שבברירת המחדל.

struct S {
    int x;        // public כברירת מחדל
};

class C {
    int x;        // private כברירת מחדל
};

החברים של struct הם public אלא אם מסמנים אחרת, והחברים של class מתחילים כ-private. זה הכול: לשניהם יכולים להיות בנאים, פונקציות חברות, ירושה וכל השאר. אפשר אפילו להוסיף ל-struct מציינֵי גישה מפורשים כדי להסתיר חברים:

#include <iostream>
using namespace std;

struct Counter {
    int value() const { return count; }   // ציבורי
    void bump() { count++; }

private:
    int count = 0;                          // עכשיו מוסתר
};

int main() {
    Counter c;
    c.bump();
    c.bump();
    cout << c.value() << "\n";   // 2
    // c.count = 99;   // שגיאת קומפילציה: count הוא פרטי
}

המסקנה המעשית: השתמשו ב-struct לחבילות נתונים שקופות שבהן כל שדה נועד לשינוי חופשי (Point, Color, רשומת הגדרות), ופנו ל-class כשרוצים להגן על מצב פנימי מאחורי ממשק ציבורי. המהדר מתייחס לשניהם אותו דבר; מילת המפתח רק מבטאת את הכוונה שלכם.

מערכים ו-vectors של structs

מכיוון ש-struct הוא טיפוס רגיל, אפשר לשים הרבה כאלה במערך או ב-vector ולעבור עליהם בלולאה כמו על כל ערך אחר.

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

struct Product {
    string name;
    double price;
};

int main() {
    vector<Product> cart = {
        {"Keyboard", 49.99},
        {"Mouse", 19.99},
        {"Monitor", 199.00},
    };

    double total = 0;
    for (const Product& p : cart) {   // const&: בלי העתקה לכל פריט
        cout << p.name << ": $" << p.price << "\n";
        total += p.price;
    }
    cout << "Total: $" << total << "\n";
}

שימו לב לסוגריים המקוננים: כל {"Keyboard", 49.99} מאתחל Product אחד ב-aggregate initialization, והסוגריים החיצוניים בונים את ה-vector. שימוש ב-const Product& בלולאת ה-range-based חוסך העתקה של כל struct בכל איטרציה: אם תורידו את ה-& תשכפלו כל איבר בלי צורך.

הבא בתור: Enums

Structs מאפשרים לבנות טיפוס מכמה ערכים שמאוגדים יחד. הפרק הבא הולך בכיוון ההפוך: enum מגדיר טיפוס שיכול להחזיק בדיוק ערך אחד מתוך קבוצה קטנה של שמות, מושלם לדברים כמו Color::Red, Direction::North או הסטטוס של מכונת מצבים. תראו איך enum class נותן קבועים קריאים ובטוחים מבחינת טיפוסים, שמשתלבים באופן טבעי עם ה-structs וה-classes שאתם בונים עכשיו.