#include <stdio.h>
int main()
{
        int a,b;
        b = 5;
        a = b++;
        return 0;
}

לעומת:

#include <stdio.h>
int main()
{
        int a,b;
        b = 5;
        a = ++b;
        return 0;
}

הראשון מתרגם לאסמבלי הבא: (gcc)

0x08048374 <main+0>:	push   ebp
0x08048375 <main+1>:	mov    ebp,esp
0x08048377 <main+3>:	sub    esp,0x10
0x0804837a <main+6>:	mov    DWORD PTR [ebp-0x4],0x5
0x08048381 <main+13>:	mov    eax,DWORD PTR [ebp-0x4]
0x08048384 <main+16>:	mov    DWORD PTR [ebp-0x8],eax
0x08048387 <main+19>:	add    DWORD PTR [ebp-0x4],0x1
0x0804838b <main+23>:	mov    eax,0x0
0x08048390 <main+28>:	leave  
0x08048391 <main+29>:	ret 

והשני ל

0x08048374 <main+0>:	push   ebp
0x08048375 <main+1>:	mov    ebp,esp
0x08048377 <main+3>:	sub    esp,0x10
0x0804837a <main+6>:	mov    DWORD PTR [ebp-0x4],0x5
0x08048381 <main+13>:	add    DWORD PTR [ebp-0x4],0x1
0x08048385 <main+17>:	mov    eax,DWORD PTR [ebp-0x4]
0x08048388 <main+20>:	mov    DWORD PTR [ebp-0x8],eax
0x0804838b <main+23>:	mov    eax,0x0
0x08048390 <main+28>:	leave  
0x08048391 <main+29>:	ret   

כמו שאתה רואה, ההבדל הוא רק בסדר, שום העתקה שום דבר.

ברגע שתגיע למצב (למרות שיש מקרי קצה) של opreator overloading אז אתה תראה הבדל משמעותי.

חוץ מזה, שבשתי הדוגמאות שהבאת, פשוט כתוב את מה שאמרת בלי הוכחה.
הלינק הזה:
http://www.velocityreviews.com/forums/t291031-prefix-vs-postfix.html
עולה כל פעם שמישהו שואל את ה"חידה" הזו.

הלינק השני:
http://www.devx.com/tips/Tip/12634
נכתב לפני כ"כ הרבה שנים, שיש מצב שלא היה אז אופטימיזציות טובות בקומפיילרים, למרות שקשה לי להאמין, ונראה לי שמה שהוא כתב שם זה בדיוק כמו שכתבת עכשיו, מבוסס על איזה סיפור אורבני. זה סוג של תושב"ה, אבל אף פעם אף אחד לא סיפק הוכחה.
אין שום סיבה שתצטרך להעתיק ואז להשתמש, שינוי הסדר יכול לסדר הכל.
תן דוגמה נגדית (קוד ו disassembly) ואז אולי יהיה לזה ביסוס.
שוב, בינתיים אין שום סיבה.

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

לגבי הקלאס, אין סיבה שהוא לא יממש את זה באותה צורה (שינוי הסדר הוא ההבדל בין המקרים).

או בקיצור, עושה רושם שגם אתה מכיר את זה בתור תושב"ה ולא באמת קימפלת ועשית disassembly לקוד כזה.

לעידן, אני הבנתי לחלוטין ואני מכיר את זה - אפילו דיברנו על זה פעם בפרטי

אבל שוב, לא מדברים על טיפוסים פרמטיביים כי גם ככה מדובר בסיבוכיות ממש זניחה ואטומית.
מדברים על operators overloading של reference type, כלומר על קלאסים ב-++C.
ושמה, אין לך שום ברירה, ההבדל בין הסיבוכיות של הפעולות הוא שמיים וארץ, וזה בכלל לא נתון לויכוח, כי לא מדובר פה בשום רמת אסמבלי, אלא ברמת המימוש שנכפת עליך.

איפה כתבתי משהו על 2 פעולות מכונה? ועל מה אתה מדבר במקרה הנ"ל שאפשר לאחד? a = ++b במקרה הכי טוב יהיה 3 פעולות מכונה (x86).

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

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

פי 50? לא יודע מאיפה הבאת פתאום את המספר הזה.

בכל מקרה, מה שאני כתבתי בתגובה הקודמת זה בסה"כ, שלא משנה איזה טיפוס,
a = ++b;
ו
++b;
a = b;
הם שקולים
וגם
a=b++;
ו
a=b;
b++;
הם שקולים.

אתה טוען ש-++b=a ו-b=++a מתנהג בדיוק כמו בטיפוסים פרמטיביים - ברור לנו שלא כי התכונה של מימוש ++a ו-a++ בכלל לא קרובים אחד לשני.
כנ"ל אם אתה מגדיר a++ ו-++a להיות אותו הדבר, רק עם סדר קדימויות שונה!
לקומפיילרים כיום אין שום אפשרות לדעת בצורה יעילה שהקוד שלך זהה בשניהם, רק שהראשון והשני מבצעים סדר קדימויות שונות (זו בעיה NPC).

לכן, הוא מבצע את הקוד 1:1 כמו שתממש אותו (או כמו שנתתי דוגמא לעי"ל).
עובר שורה שורה בקוד ומבצע בדיוק מה שרשמתי.
זו המשמעות של operators overloading ב-++C, אם אתה לא מכיר.

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

ובנוגע לשאר הערות:
1. ברור שהקוד לא יתקמפל כי הקלאס מוצהר חלקית ועכשיו אני רואה שרשמתי temp ו-tmp. זה היה עצוב אם הייתי במצב שבשביל קטע קוד כזה הייתי צריך קומפיילר.
2. גם כשאתה רושם באסמבלי 2 ויותר פקודות מכונה, המעבד יכול לאחד אותן, לבצע אופטימיזציות קאש ובקיצור - הרבה הרבה דברים שאי אפשר להסתמך עליהם רק לפי קריאת קוד אסמבלי וספירת מספר השורות שלו, אבל זה בכלל לא העניין כרגע כי אני מדבר על רפרנס טייפ ולא וואליו טייפ.
3. אם עדיין לא הבנת, אני התעייפתי. נסה לעבור שוב על כל האשכול ואולי מישהו אחר יחליף אותי פה בשביל להסביר לך למה אתה טועה בטענה שלך