אני לומד עכשיו C++.

נתקלתי בדבר מוזר כזה:

http://cplus.eitan.ac.il/main.php?id1=3&id2=3&id3=3&id4=1

Sub(int a, int b, int c): 
 Base1(a), Base2(b), z(c) {}

איך זה ייתכן שמכניסים ערך ל-z בצורה כזאת:

z(c)

הרי z הוא לא פונקציה. זה נכון בכלל מה שהם עשו? ובאיזה מקרים משימים ערך ל- z בצורה כזאת וממה זה שונה מ- z=c ?

שאתה יוצר משתנה יש לו ערך התלחלתי שהוא לרוב ג'יבריש...

אתה יכול ליצור כל משתנה עם ( ערך התחלתי ) ועם קיים CTOR שמתאים לזה הוא ייצור אותו עם הערך הזה.

זה תכף גם למשתנים בסיסים כמו INT.

נגיד יש לך CLASS C ובתוכו משתנה CHAR * שיכיל בעתיד מחרוזת, ונגיד שאתה רוצה לאתחל אותו ל-NULL שלא יהיה לך בעיות איתו, אז אתה יכול לכתוב

class alon
{
alon () : pChar ( NULL ) {}
char *pChar;
};

מקווה שלא סיבכתי אותך.

\עריכה

חשוב לכתוב את הסדר של אתחול המשתנים לפי הסדר שהם כתובים ב-CLASS, יש קומפיילרים שלא אוהבים את זה אחרת ( לא קריטי לכתיבה ב-VISUAL STUDIO ).

נוקודתיים בעצם מחליפים { } ?

והמבנה שבה צריך לכתוב אחרי נקודתיים הוא שונה מאשר {}. והשמה למשתנים מתבצעת כמו קריאה לפונקציות?

לא לא

class alon
{
private:
int a, b, c;
public:
alon ( int value ) : a ( value ), b ( 0 )
{     
   c = a - b;        
}     
}; 

אומר שאתה בונה CLASS שדורש שאתה בונה אותו ערך ( VALUE ), ושהוא מאותחל, הוא שם אותו ב-A.

ב-B הוא שם 0

ב-C הוא שם את החיסור שלהם, שיצא בעצם VALUE...

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

הקוד הבא:

class C
{
 private:
  int a;
 public:
  C(int value) : a(value)
  {
  }
};

כמעט זהה לקוד הבא:

class C
{
 private:
  int a;
 public:
  C(int value)
  {
   a = value;
  }
};

מה בכל זאת ההבדל?

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

במקרה הראשון, ה-ctor שם את value ב-a כבר בזמן שהאובייקט נוצר.

למה זה טוב?

נניח שיש לך את הקלאס הבא:

class myClass
{
 private:
  int x;
 public:
  myClass(int value)
  {
   x = value;
  }
};

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

myClass a;

אלא חייבים ככה:

myClass a(5);

(כשכמובן במקום 5 יכול לבוא כל int)

עכשיו, נניח שיש לך קלאס כזה:

class OtherClass
{
 private:
  MyClass c;
 public:
  OtherClass(int value)
  {
   c = MyClass(value);
  }
};

כלומר OtherClass מחזיק בתוכו אובייקט מטיפוס MyClass, והוא מאתחל אותו ב-ctor. קוד כזה לא יתקמפל. למה? כי הקומפיילר מנסה לאתחל את c באמצעות ה-ctor הדיפולטי שלו (לפני הכניסה בכלל ל-ctor של OtherClass) - אבל הוא לא יכול, כי אין כזה. לכן, חייבים לאתחל את c לפני שמאתחלים את OtherClass:

class OtherClass
{
 private:
  MyClass c;
 public:
  OtherClass(int value) : c(value)
  {
  }
};

קפיש?

תודה רבה על הסברים המושקעים.

אבל יש לי בעייה אחת המונעת ממני להבין. מה זה ctor?

ויש לי עוד שאלה private: רושמים כאשר ניתן לקרוא למשתנה / פונקציה רק מתוך פונקצית חבר מאותו ה- class?

ורושמים public: כשניתן לקרוא מכל מקום?

ctor = constructor

וכן, זה בדיוק private ו-public.