מה ההבדל, לא חייב להיות מדובר על i

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

http://www.fresh.co.il/vBulletin/showthread.php?t=96215

תמצא את הספר More Effective CPP של Scott Meyers
בספר הזה תקרא את פריט מספר 6:
Item 6: Distinguish between prefix and postfix forms of increment and decrement operators
מה שכתוב פה יבהיר לך בדיוק את ההבדל בין צורות הפוסט/פרה-פיקס של אופרטור הוספה הורדה.

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

בכל מקרה - ממליץ על הספר.

בארבעת הסעיפים הראשונים של הספר מוסבר מדוע יש להעדיף inline ו-const על ‎#define‏...

בערך יומיים מאוחר מדי.

אתה לא שוכח כלום, הא?

ציטוט:

במקור נכתב על ידי danben תמצא את הספר More Effective CPP של Scott Meyers בספר הזה תקרא את פריט מספר 6: Item 6: Distinguish between prefix and postfix forms of increment and decrement operators מה שכתוב פה יבהיר לך בדיוק את ההבדל בין צורות הפוסט/פרה-פיקס של אופרטור הוספה הורדה. אני לא יודע אם מותר לי לצטט משם אז אני לא אעשה את זה אבל לדעתי אתה יכול למצוא את הספר באימיול....(או אולי בספריה הקרובה למקום מגוריך) בכל מקרה - ממליץ על הספר.

מה כל ההתחבטות? הפניות לספרים? מאמרים?


האין זו תחרות חפרנות והתברברות?

זה הוספה וזה הפחתה 8)

צורות ה-postfix וה-prefix של האופרטור ++ - שתיהן מגדילות את ערך האופרנד באחד, בסופו של דבר. הפחתה זה --.

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

קוד:

int x = 5;

 
 
int y = x++; //y=5, x=6

קוד:

int x = 5; 
 
 
int y = ++x; //y=6, x=6

זה לא קשור רק ל"לפני" ול"אחרי".

בוא נחשוב ביחד איך ה"אחרי" ממומש:
במצב "רגיל" היה מחושב כל ה-"rvalue"(מה שמימין לאופרטור ההשמה), ונזרק לתוך
ה-lvalue(מה שמשמאל לאופרטור ההשמה). אבל אצלנו זה לא ככה. איך זה יכול להיות?
כיצד זה ייתכן?!
פשוט מאוד. הגיון רגיל והגיון CPP-י הם דברים שונים לגמרי. במקרה של גרסת ה-postfix
נוצר עותק של המשתנה, בעל הערך הישן, המשתנה הנוכחי מקודם באחד, והאופרטור
מחזיר את העותק עם הערך הישן.

פסאודו קוד CPP לעסק היה נראה בערך כך:

קוד:

const int& operator++(void) //prefix
{
	this += 1;  //pseudo-code. disregard the pointer issue
	return this;
}

const int& operator++(int zift) //postfix
{
	int tmp(this); //ditto
	this += 1;
	return itmp;
}

סבבה? לא רק האפקט שונה, אלא גם הדרך שונה.

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

--
גל דיסקין (gal diskin)

עצות והמלצות:

על-סמך מה אתה אומר שזה עד כדי כך משמעותי?

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

C pogrammers never die. They are just cast into void.

לא אשב בשקט, אעדיף ללמוד מהטעות שעשיתי, בקריאה לא נכונה, פזיזות בקיצר.

ציטוט:

במקור נכתב על ידי Amir256 כשהאופרטור ++ נמצא מימין למשתנה, המשתנה מקודם באחד אחרי ביצוע הפעולה וכשהוא נמצא משמאל, המשתנה מקודם באחד לפני ביצוע הפעולה. לדוגמא, בקטע קוד הראשון, קודם מתבצעת ההשמה ל-y ורק אח"כ x מקודם באחד. בקטע השני x מקודם באחד ורק אח"כ מבוצעת ההשמה ל-y קוד: int x = 5; int y = x++; //y=5, x=6 קוד: int x = 5; int y = ++x; //y=6, x=6

מסבר מעולה!!