מחלקות ב-C++: הגדרת אובייקטים, חברים ומתודות

מה זו מחלקה

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

כבר השתמשתם במחלקות בלי להגדיר אף אחת: std::string והמכל vector הם מחלקות מהספרייה הסטנדרטית. קריאה ל-name.length() או ל-v.push_back(3) היא קריאה לפונקציה חברה על אובייקט. עכשיו תבנו טיפוסים משלכם באותה דרך, ואחר כך תעברו לבנאים שמאתחלים אותם.

הגדרת מחלקה ויצירת אובייקטים

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

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

class Dog {
public:
    string name;   // משתנה חבר
    int age;       // משתנה חבר

    void bark() {  // פונקציה חברה
        cout << name << " says woof!" << endl;
    }
};

int main() {
    Dog rex;            // יצירת אובייקט (מופע)
    rex.name = "Rex";   // השמה לחברים עם האופרטור .
    rex.age = 4;

    Dog luna;           // אובייקט שני, עצמאי
    luna.name = "Luna";

    rex.bark();
    luna.bark();
    return 0;
}

rex ו-luna הם שני אובייקטים נפרדים. שינוי של rex.name לא נוגע ב-luna.name: כל אובייקט מחזיק את הנתונים שלו. ניגשים לחבר עם אופרטור הנקודה . על אובייקט (או עם -> כשיש מצביע אליו).

public מול private

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

#include <iostream>
using namespace std;

class Counter {
private:
    int count = 0;            // מוסתר: קוד חיצוני לא יכול לגעת בו

public:
    void increment() {        // הממשק הבטוח
        count++;
    }
    int value() const {       // const: הפונקציה הזו לא תשנה את האובייקט
        return count;
    }
};

int main() {
    Counter c;
    c.increment();
    c.increment();
    cout << "Count: " << c.value() << endl;

    // c.count = 100;   // שגיאה: 'count' הוא private
    return 0;
}

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

הצהרה מול הגדרה של מתודות

במחלקות קטנות, הגדרת מתודות בתוך המחלקה (כמו למעלה) היא בסדר. בגדולות יותר מקובל להצהיר על המתודות בתוך המחלקה ולהגדיר את הגוף שלהן מחוץ לה, עם תחביר הטווח ClassName::method. כך הגדרת המחלקה נשארת קריאה, כסיכום של הממשק.

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

class Rectangle {
public:
    double width;
    double height;

    double area() const;        // הצהרה בלבד
    void describe() const;      // הצהרה בלבד
};

// ההגדרות נמצאות בחוץ, עם הקידומת Rectangle::
double Rectangle::area() const {
    return width * height;
}

void Rectangle::describe() const {
    cout << width << " x " << height
         << " = " << area() << endl;   // אפשר לקרוא לחברים אחרים ישירות
}

int main() {
    Rectangle r;
    r.width = 3.0;
    r.height = 4.0;
    r.describe();
    return 0;
}

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

המצביע this

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

#include <iostream>
using namespace std;

class Point {
public:
    int x = 0;
    int y = 0;

    void setX(int x) {     // הפרמטר 'x' מסתיר את החבר 'x'
        this->x = x;       // this->x הוא החבר; x הוא הפרמטר
    }

    void print() const {
        cout << "(" << x << ", " << y << ")" << endl;
    }
};

int main() {
    Point p;
    p.setX(7);
    p.print();
    return 0;
}

בלי this->, כתיבת x = x; בתוך setX הייתה משימה את הפרמטר לעצמו ומשאירה את החבר ללא שינוי: באג שקט. this->x מסיר את העמימות. בסיסי קוד רבים נמנעים מהבעיה לגמרי בכך שהם נותנים לפרמטרים שמות אחרים (למשל setX(int newX)), אבל תראו את this-> כל הזמן בקוד אמיתי.

טעויות נפוצות

כמה מלכודות של מחלקות תופסות אנשים שוב ושוב:

• שכחת הנקודה-פסיק הסוגרת. הגדרת מחלקה מסתיימת ב-};. השמיטו את ה-; ותקבלו מבול של שגיאות מבלבלות שמצביעות על מה שבא אחרי המחלקה, לא על המחלקה עצמה.
• שכחה לאתחל חברים. חברים מטיפוסים מובנים כמו int ו-double לא מאופסים אוטומטית. קריאה של חבר לא מאותחל היא undefined behavior. תנו לחברים ערכי ברירת מחדל (int count = 0;) או אתחלו אותם בבנאי.
• גישה לחברים פרטיים מבחוץ. c.count = 5; על חבר פרטי היא שגיאת הידור: עברו דרך מתודה ציבורית. זה הכימוס שעובד כמתוכנן.
• בלבול בין המחלקה לאובייקט. Dog.bark(); שגוי: Dog הוא הטיפוס. קוראים למתודות על אובייקטים: rex.bark();.

// חבר לא מאותחל: קריאה של 'age' היא undefined behavior:
class Cat {
public:
    int age;            // אין ערך ברירת מחדל
};

Cat c;
std::cout << c.age;     // ערך זבל, לא 0

הבא בתור: בנאים

השמה ידנית לכל חבר אחרי יצירת אובייקט, rex.name = ...; rex.age = ...;, מייגעת וקל לשכוח אותה, וזו בדיוק הדרך שבה מגיעים לחברים לא מאותחלים. העמוד הבא עוסק בבנאים (constructors): פונקציות מיוחדות שרצות אוטומטית כשאובייקט נוצר, ומאפשרות להבטיח שכל אובייקט מתחיל במצב תקין עם תחביר נקי של שורה אחת, Dog rex("Rex", 4);.