ווטסאפ - לינוקס, BSD, קוד פתוח ותוכנה חופשית בעברית. Whatsup - Linux, BSD, open source and free software in Hebrew

 
 
  כניסת חברים · רישום · שכחתי סיסמה  
tux the penguin
תגובה לנושא
צפיה בנושא הבא Printable version התחבר כדי לבדוק הודעות פרטיות צפיה בנושא הקודם
אורח · ·
 

הודעה פורסם: 14/03/2018 - 12:11
נושא ההודעה: העמסת אופרטורים, מנסה להבין?

קוד:
#include<iostream>
using namespace std;
 
class car {
public:
     int seats;
   
    car operator + (car model) {
         return model;
    }

   
};
 
int main() {

    car suz;
    suz.seats = 5;
    cout << suz.seats << endl;


    car nis;
    nis.seats = 10;
    cout << nis.seats << endl;

    suz = nis + suz;
    cout << suz.seats << endl;

}


מה אני אמור להוסיף במתודה כדי שאופרטור החיבור של המחלקה car יחבר לי את 2 הערכים של האובייקטים? תודה
 
   
תגובה  עם ציטוט חזרה למעלה
חזרה לתוכן הדיון
אורח · ·
 

הודעה פורסם: 14/03/2018 - 16:57
נושא ההודעה:

משהו כזה:
קוד:

car operator + (car model) {
   car plusmodel;
   plusmodel.seats = model.seats + this.seats;

   return plusmodel;
}

תסלח לי אם יש טעויות פעם אחרונה שכתבתי c++ היתה לפני הרבה שנים
 
   
תגובה  עם ציטוט חזרה למעלה
חזרה לתוכן הדיון
צפריראורח · ·
 

הודעה פורסם: 14/03/2018 - 17:47
נושא ההודעה:

הערה:

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

כמוכן שם האופרנד הוא model. האם מדובר כאן על אובייקט שהוא מכונית או דגם מכונית?
 
   
תגובה  עם ציטוט חזרה למעלה
חזרה לתוכן הדיון
אורח · ·
 

הודעה פורסם: 14/03/2018 - 20:14
נושא ההודעה: אם אני מחליף את המתודה שכתבתי בשלך מתקבלת שגיאה

Anonymous :
משהו כזה:
קוד:

car operator + (car model) {
   car plusmodel;
   plusmodel.seats = model.seats + this.seats;

   return plusmodel;
}

תסלח לי אם יש טעויות פעם אחרונה שכתבתי c++ היתה לפני הרבה שנים

אולי תסביר מה ניסית לעשות? למעשה הבנתי שהעמסת אופרטורים אמורה להריץ קוד אחר בזמן שימוש באופרטור הרלוונטי, ומנסיון שעשיתי ראיתי שבקוד שאני כתבתי האופרנד שמועבר כפרמטר למתודה הוא תמיד הימני, מה שאני לא מצליח זה לגשת לאופרנד השמאלי (או באמצעות העברה כפרמטר, או באמצעות גישה מתוך המתודה), אז איל לעז*** עושים את זה?
 
   
תגובה  עם ציטוט חזרה למעלה
חזרה לתוכן הדיון
אורח · ·
 

הודעה פורסם: 14/03/2018 - 20:17
נושא ההודעה:

צפריר :
הערה:

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

כמוכן שם האופרנד הוא model. האם מדובר כאן על אובייקט שהוא מכונית או דגם מכונית?

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

הודעה פורסם: 14/03/2018 - 20:19
נושא ההודעה:

קוד:

class foo{
private:
int val;
public:
int operator+(const foo & rhs)
{
val += rhs.val;
{
};
 
   
תגובה  עם ציטוט חזרה למעלה
חזרה לתוכן הדיון
אורח · ·
 

הודעה פורסם: 14/03/2018 - 20:51
נושא ההודעה: Re: אם אני מחליף את המתודה שכתבתי בשלך מתקבלת שגיאה

Anonymous :
מה שאני לא מצליח זה לגשת לאופרנד השמאלי (או באמצעות העברה כפרמטר, או באמצעות גישה מתוך המתודה), אז איל לעז*** עושים את זה?

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

הודעה פורסם: 15/03/2018 - 09:56
נושא ההודעה:

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

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

קוד:
int i=1;
int j = 2
int k;
k = i + j;


אם אני כותב כעת קוד שמגדיר מחלקה של, נאמר, וקטור דו-מימדי, אני יכול להגדיר לו אופרטורים אריתמטיים כדי לתת לו "התנהגות" מתמטית הגיונית. למשל, אני יכול להחליט שהתוצאה ההגיונית של פעולת חיבור על וקטור כזה היא חיבור של כל רכיב לרכיב המתאים. למשל, אם אני מחבר את הוקטורים (2,3) ו-(5,3) אני רוצה שהתוצאה תהיה (7,6).

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

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

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

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


קוד:
friend Car operator+(const Car& a, const Car& b)
{
    Car c;
    c.seats = a.seats + b.seats;
    return c;
}
; //in class


הפונקציה צריכה להיות מוגדרת בתוך המחלקה Car.

רק כהערה, השאלה שלך מאד בסיסית ונראה שאתה בתחילת הדרך של לימוד C++. אם תשאל אותי, כדאי שתמצא ספר טוב ותלמד בצורה מסודרת גם עקרונות כלליים של objec oriented programming וגם את עקרונות השפה.
 
   
תגובה  עם ציטוט חזרה למעלה
חזרה לתוכן הדיון
אורח · ·
 

הודעה פורסם: 15/03/2018 - 21:50
נושא ההודעה:

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

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

קוד:
int i=1;
int j = 2
int k;
k = i + j;


אם אני כותב כעת קוד שמגדיר מחלקה של, נאמר, וקטור דו-מימדי, אני יכול להגדיר לו אופרטורים אריתמטיים כדי לתת לו "התנהגות" מתמטית הגיונית. למשל, אני יכול להחליט שהתוצאה ההגיונית של פעולת חיבור על וקטור כזה היא חיבור של כל רכיב לרכיב המתאים. למשל, אם אני מחבר את הוקטורים (2,3) ו-(5,3) אני רוצה שהתוצאה תהיה (7,6).

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

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

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

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


קוד:
friend Car operator+(const Car& a, const Car& b)
{
    Car c;
    c.seats = a.seats + b.seats;
    return c;
}
; //in class


הפונקציה צריכה להיות מוגדרת בתוך המחלקה Car.

רק כהערה, השאלה שלך מאד בסיסית ונראה שאתה בתחילת הדרך של לימוד C++. אם תשאל אותי, כדאי שתמצא ספר טוב ותלמד בצורה מסודרת גם עקרונות כלליים של objec oriented programming וגם את עקרונות השפה.

א. תודה על התשובה המושקעת.
ב. אז הנה התוכנית המעודכנת שאכן פועלת כשורה:
קוד:
#include<iostream>
using namespace std;
 
class car {
 
public:
    int seats;
 
   friend car operator + (const car & modelA, const car& modelB) {
         car modelC;
         modelC.seats = modelA.seats +  modelB.seats;
         return modelC;
    }
};
 
int main() {
    car suz;//suzuki
    suz.seats = 5;

    car nis;//nissan
    nis.seats = 4;

    car newcar;
    newcar = suz + nis;
    cout <<"seats: "<<  newcar.seats << endl ; 
}

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

ג. בתוכניות שאני נתקלתי יש תחביר שונה למתודה, בלי המילה השמורה friend, כך:


קוד:
    car operator + (const car & modelA, const car& modelB) {
         car modelC;
         modelC.seats = modelA.seats +  modelB.seats;
                return modelC;
    }

זה לא עובד לי אלא מחזיר לי את השגיאות:
קוד:
error: ‘car car::operator+(const car&, const car&)’ must take either zero or one argument.
error: no match for ‘operator+’ in ‘suz + nis’


ואני שואל למה הוא חייב לקבל 0 או ארגומנט אחד, הרי הגדרתי אותו ל-2.

ד. תחביר נוסף שנתקלתי לדוגמה כאן (https://www.tutorialspoint.com/cplusplus/cpp_overloading.htm) והוא אכן עובד, כך:
קוד:
  car operator + (car const & modelA) {
         //cout << modelA.seats;
         car modelB ;
         modelB.seats = seats +modelA.seats;
         return modelB;
}


וכאן אני שואל: אם הפונקציה מקבלת רק פרמטר אחד (modelA) שמקבל את האופרנד הימני (nis - כדי להוכיח את זה הוספתי את פקודת ה-cout באמצע הפונקציה) איך המהדר "יודע" לגשת אל האופרנד השמאלי של פעולת החיבור(suz)? אני מניח ש-modelB מקבל את המידע מהשדה seats, (בפקודה modelB.seats = seats), אבל למה seats מוצב כעת עם הערכים של suz?
 
   
תגובה  עם ציטוט חזרה למעלה
חזרה לתוכן הדיון
עמיתאורח · ·
 

הודעה פורסם: 15/03/2018 - 23:04
נושא ההודעה:

לגבי שאלה ד, כשאתה משתמש בשם של משתנה (או מתודה) ששייכים לאובייקט עליו נקראת הפונקציה, הקומפיילר יודע שהם שייכים לאובייקט. לכן אם כתבת רק "seats" הקומפיילר יודע שזה המשתנה ששייך לאובייקט (כנראה suz בקוד שלך) שעבורו אתה קורא לאופרטור + (כלומר, האובייקט שנמצא משמאל לאופרטור).

במילים אחרות, אם כתבת, למשל:

קוד:
foo + bar


למעשה מה שקורה הוא קריאה לפונקציה בצורה הבאה:

קוד:
foo.operater+(bar)


(שם הפונקציה הוא operator+)

לגבי ג, בכל קריאה ל-member method מועבר עוד ארגומנט שאתה לא כותב אותו באופן מפורש, שהוא מצביע לאובייקט עליו נקראה הפונקציה. לכן, אם הגדרת, למשל:



קוד:

class X
{
   f(int i) {/*...*/}
}


ועכשיו תכתוב:

קוד:

X x;
x.f(42);


הקומפיילר מייצר, למעשה, את הקריאה הבאה:

קוד:

x.f(this, 42);


כאשר this הוא מצביע לאובייקט עליו נקראה הפונקציה (x, בדוגמה זו).

אופרטור + יכול להיות, בעצם, שני דברים – או אופרטור בינארי שמשמש לחיבור, או אופרטור אונארי (כלומר, פועל על אופרנד אחד). C++ מאפשרת לך העמסה, אבל היא מחייבת אותך לשימוש מסויים – אופרטור + שהוא member יכול לקבל אופרנד מפורש אחד (שאתה מעביר) אם הוא בינארי (ובנוסף מועבר this), או אף אופרנד מפורש אם הוא אונארי.

במקרה שהגדרת את האופרטור כ-member אבל העברת לו שני ארגומנטים, למעשה הועברו לו 3 כי הקומפיילר מעביר לו את this, ולכן קיבלת את ההודעה שאומרת שאתה יכול להעביר רק אחד או אפס.
 
   
תגובה  עם ציטוט חזרה למעלה
חזרה לתוכן הדיון
אורח · ·
 

הודעה פורסם: 18/03/2018 - 11:40
נושא ההודעה: סיכום ביניים

לאחר חפירה נוספת יצא לי שיש בעצם 3 אפשרויות עקרוניות להעמסת אופרטורים.

א.
קוד:

    int seats;
    car operator + (car model) {
        car modelB;
        modelB.seats = seats +  model.seats;
        return modelB;
    }


מאפיינים: 1. הגדרה בתוך המחלקה כמתודה(?). 2. שימוש בפרמטר פורמלי אחד כשהאופרנד השמאלי של הפעולה האופרטורית, מועבר על ידי this.

ב.
קוד:
    friend car operator + (car  modelA, car modelB) {
         modelA.seets +=  modelB.seets;
         modelA.pass += modelB.pass;
         return modelA;
    }

מאפיינים: 1. הגדרה בתוך המחלקה כ"חבר". 2. שימוש ב-2 פרמטרים פורמליים (אין this).

ג.
קוד:
car operator + (car  modelA,car modelB) {
    car modelC;
    modelC.seets =modelA.seets +  modelB.seets;
    return modelC;
}

מאפיינים: 1. הגדרה כפונקציה גלובלית מחוץ להגדרת המחלקה. 2. שימוש ב-2 פרמטרים פורמליים (אין this).

השאלות שנותרו לי הם 1. האם א' מוגדר כמתודה? 2. האם friend מוגדר כמתודה? 3. האם יש אפשרות ליישם פונקציה גלובלית עם פרמטר פורמלי אחד? 4. האם ניתן לבצע העמסת אופרטורים על פעילות שאינה על אבייקטים לדוגמה ש-
קוד:
int w =1 + 2
יהיה 21, כי האופרטור + של int יחזיר כפל של התוצאה שאמורה להיות (3) ב-7?
 
   
תגובה  עם ציטוט חזרה למעלה
חזרה לתוכן הדיון
אורח · ·
 

הודעה פורסם: 18/03/2018 - 12:54
נושא ההודעה: Re: סיכום ביניים

ציטוט:


השאלות שנותרו לי הם 1. האם א' מוגדר כמתודה? 2. האם friend מוגדר כמתודה? 3. האם יש אפשרות ליישם פונקציה גלובלית עם פרמטר פורמלי אחד? 4. האם ניתן לבצע העמסת אופרטורים על פעילות שאינה על אבייקטים לדוגמה ש-
קוד:
int w =1 + 2
יהיה 21, כי האופרטור + של int יחזיר כפל של התוצאה שאמורה להיות (3) ב-7?

המילה מתודה היא מילה שניתן לתאר איתה כמה דברים, לא חושב שיש הגדרה סגורה לזה.
יש פונקציה שחברה במחלקה ויש את כל השאר
לכן לגבי 2 זה פונקציה שהיא חברה *של* המחלקה (יש לה גישה לשדות פרטיים של המחלקה), היא לא חברה *ב*מחלקה
לגבי 3 אפשר לעשות מה שרוצים, השאלה מה תקבל, פונקציה גלובלית עם פרמטר אחד היא תהיה רק עם פרמטר אחד, זה עוזר לך במשהו?
4. לא ניתן. עושים את זה על ידי wrapper כשהכוונה מחלקה עוטפת. בכלל כדאי למעט בהעמסת אופרטורים ששונים מהמשמעות של האופרטור בעולם האמיתי.

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

הודעה פורסם: 18/03/2018 - 13:01
נושא ההודעה:

זה פשוט כמו כל מתודה (פונקציה שחברה באובייקט לפי ההגדרה לעיל) שמופעלת עם האופרטור על האובייקט. אתה יכול לעשות מה שאתה רוצה בלי העמסת אופרטורים ויש שפות שבכלל לא מאפשרות את זה כמו java.
עדיף ללמוד java לפני C++ לפי דעתי האישית.
 
   
תגובה  עם ציטוט חזרה למעלה
חזרה לתוכן הדיון
אורח · ·
 

הודעה פורסם: 18/03/2018 - 18:16
נושא ההודעה: Re: סיכום ביניים

Anonymous :
ציטוט:


השאלות שנותרו לי הם 1. האם א' מוגדר כמתודה? 2. האם friend מוגדר כמתודה? 3. האם יש אפשרות ליישם פונקציה גלובלית עם פרמטר פורמלי אחד? 4. האם ניתן לבצע העמסת אופרטורים על פעילות שאינה על אבייקטים לדוגמה ש-
קוד:
int w =1 + 2
יהיה 21, כי האופרטור + של int יחזיר כפל של התוצאה שאמורה להיות (3) ב-7?

המילה מתודה היא מילה שניתן לתאר איתה כמה דברים, לא חושב שיש הגדרה סגורה לזה.
יש פונקציה שחברה במחלקה ויש את כל השאר
לכן לגבי 2 זה פונקציה שהיא חברה *של* המחלקה (יש לה גישה לשדות פרטיים של המחלקה), היא לא חברה *ב*מחלקה
לגבי 3 אפשר לעשות מה שרוצים, השאלה מה תקבל, פונקציה גלובלית עם פרמטר אחד היא תהיה רק עם פרמטר אחד, זה עוזר לך במשהו?
4. לא ניתן. עושים את זה על ידי wrapper כשהכוונה מחלקה עוטפת. בכלל כדאי למעט בהעמסת אופרטורים ששונים מהמשמעות של האופרטור בעולם האמיתי.

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

יש לדעתך שיטה מועדפת ליישום מבין אלו שהוזכרו?
 
   
תגובה  עם ציטוט חזרה למעלה
חזרה לתוכן הדיון
אורח · ·
 

הודעה פורסם: 18/03/2018 - 18:18
נושא ההודעה: לגבי הסיפא של דבריך

Anonymous :
זה פשוט כמו כל מתודה (פונקציה שחברה באובייקט לפי ההגדרה לעיל) שמופעלת עם האופרטור על האובייקט. אתה יכול לעשות מה שאתה רוצה בלי העמסת אופרטורים ויש שפות שבכלל לא מאפשרות את זה כמו java.
עדיף ללמוד java לפני C++ לפי דעתי האישית.

שתלמד c++ תדע את העקרונות של ג'אווה.
 
   
תגובה  עם ציטוט חזרה למעלה
חזרה לתוכן הדיון
borsoodלא בפורום כעת ת.הצטרפות: 05/01/2007 · הודעות: 281 ·
 

הודעה פורסם: 19/03/2018 - 07:09
נושא ההודעה: Re: סיכום ביניים

[quote="Anonymous"]
Anonymous :
ציטוט:


השאלות שנותרו לי הם 1. האם א' מוגדר כמתודה? 2. האם friend מוגדר כמתודה? 3. האם יש אפשרות ליישם פונקציה גלובלית עם פרמטר פורמלי אחד? 4. האם ניתן לבצע העמסת אופרטורים על פעילות שאינה על אבייקטים לדוגמה ש-
קוד:
int w =1 + 2
יהיה 21, כי האופרטור + של int יחזיר כפל של התוצאה שאמורה להיות (3) ב-7?


יש לדעתך שיטה מועדפת ליישום מבין אלו שהוזכרו?

1. כן, "פונקציה של מחלקה" היא מתודה.
2. לא, friend אינה מתודה - ל this אין משמעות.
3. לפעולת החיבור לא. כיוון שהיא דורשת שני ארגומנטים (לא להתבלבל עם פלוס אונרי).
4. לא, אופרטורים על סוגי המשתנים שאינם אובייקטים הם בשליטת המהדר.

לפעולות כמו פעולת החיבור מעדיפים friends בגלל חוק החילוף, lvalues ועוד נושאים מתקדמים שלא כדאי שתיכנס אליהם בשלב הזה.

ל98% מהמחלקות שתכתוב בחיים לא צריך operator overloading בגלל שכמו בדוגמה שכתבת אין משמעות בעולם האמיתי לחיבור מכוניות.
(ל 99.95% מהשאר תכתוב () operator אבל זה שימוש אחר ממה שאתה לומד עכשיו)
 
 צפיה בפרופיל המשתמש שלח הודעה פרטית ביקור באתר המפרסם  
תגובה  עם ציטוט חזרה למעלה
חזרה לתוכן הדיון
אורח · ·
 

הודעה פורסם: 19/03/2018 - 18:06
נושא ההודעה:

מומלץ לקחת ספר על אלגוריתמים וללמוד דרכו גם את השפה. יש כאלה בטח בעברית (לא מכיר).
 
   
תגובה  עם ציטוט חזרה למעלה
חזרה לתוכן הדיון
אורח · ·
 

הודעה פורסם: 19/03/2018 - 21:08
נושא ההודעה:

ספר למי שרוצה להתחיל ללמוד תכנות:

https://introcs.cs.princeton.edu/java/home/
 
   
תגובה  עם ציטוט חזרה למעלה
חזרה לתוכן הדיון
הצגת הודעות מלפני:     
מעבר אל:  
כל הזמנים הם GMT + 2 שעות
תגובה לנושא
צפיה בנושא הבא Printable version התחבר כדי לבדוק הודעות פרטיות צפיה בנושא הקודם
PNphpBB2 © 2003-2004 

תוכן הדיון

  1. אורח
  2. אורח
  3. אורח [צפריר]
  4. אורח
  5. אורח
  6. אורח
  7. אורח
  8. אורח [עמית]
  9. אורח
  10. אורח [עמית]
  11. אורח
  12. אורח
  13. אורח
  14. אורח
  15. אורח
  16. borsood
  17. אורח
  18. אורח

Google Ads