לפני זמן רב נכתב בפורום PHP שלולאת FOR הקלאסית בקצת מהירה יותר מ-while המקבילה לה.

אני מדבר על לולאת FOR כדוגמת הבאה:

קוד PHP:

 for ($i=0; $i<3; ++$i)
{
 //...
} 


ייתכן וזה נכון גם לגבי לולאות FOR אחרות.

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

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

תודה!

דוגמא משפת C:
בהינתן שני הלולאות הבאות:

קוד:

    count = 0;
    while(count != 10){
        count++;
    }

עבור לולאה זו האסמבלי המתקבל הוא:

קוד:

mov    DWORD PTR [ebp-0x8],0x0
jmp    0x80483e2 <main+30>
add    DWORD PTR [ebp-0x8],0x1
cmp    DWORD PTR [ebp-0x8],0xa
jne    0x80483de <main+26>

ועבור:

קוד:

    for(count = 0; count != 10; count++){

    }

קוד האסמבלי המקתבל הוא:

קוד:

mov    DWORD PTR [ebp-0x8],0x0
jmp    0x80483f5 <main+49>
add    DWORD PTR [ebp-0x8],0x1
cmp    DWORD PTR [ebp-0x8],0xa
jne    0x80483f1 <main+45>

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

קוד:

count = 0;
for( ; count!=10; ){
count++;
}

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

למעשה, פרט לכך שבקוד ה-ASSEMBLY ה-FOR וה-WHILE ממוקמים במקומות שונים בזיכרון, אין באמת הבדל בקוד (תקן אותי אם אני טועה).
חוץ מזה, הסבר מעולה

[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://www.yarntomato.com/percentbarmaker/button.php?barPosition=90&leftFill=BBC7CE]

ציטוט:

במקור נכתב על ידי talaus למעשה, פרט לכך שבקוד ה-ASSEMBLY ה-FOR וה-WHILE ממוקמים במקומות שונים בזיכרון, אין באמת הבדל בקוד (תקן אותי אם אני טועה).

למה הם ממוקמים במקומות שונים בזיכרון?

for ו while הן בעצם סה"כ אותה לולאה, אותו תנאי (בכל קומפיילר תראו דרך שונה לייצוג שלו, לפעמים בדיקה ישירה של התנאי ולפעמים רק בסוף, תלוי אם משתמשים בcl או בgcc או בכל דבר אחר...ובגירסא..)
כל הקוד ממוקמם ב.text כREADONLY וכל כתיבה לשם תיצור שגיאה, המשתנים לרוב (לרוב, אלא אם לא השתמשנו בmalloc,static,const, אולי עוד כמה שאני לא זוכר ) מוגדרים במחסנית/stack ונדרסים בכל פעם שהפונקציה מסיימת את ייעודה.
כל לולאת for אפשר לעשות בwhile וכנ"ל בdo while וכ' וכ'

ועכשיו, לגבי מה יותר מהיר, יש כל מיני שיטות שאפשר לקרוא עליהן פה (או פה בכלליות יותר) לתת אופטימיזציה ללולאות, תלוי עד כמה מתוחכם הקומפיילר וכמה אתה יודע להשתמש בכלים שהוא נותן לך (כל מיני magical __macro__voodoo כאלה).
ושוב, כל דבר תלוי בקומפיילר ובסביבה שאנחנו משתמשים. PHP בכלל משוגעת ועושה הרבה מאוד דברים אפלים (עם הרבה מאוד טבלאות האש) שלא כדאי להתעסק איתה P:
אם אתה ממש קטנוני אתה יכול להשתמש בstime או nanotime (אני לא זוכר את השם המדוייק של הפונק') שסופרת זמן ולהשוות את זמני הריצה של כל לולאה (זה מן ויכוח כמו מה יותר טוב - echo או print, יש כלכך הרבה פונק' ושמות לא סדרתיים שעולים ודורסים אחד את השני בPHP שזה פשוט משגע לפעמים)

שאני עשיתי את אותו ניסוי (ועוד קימפלתי בכוונה בלי אופטימזציה של הקומפיילר) עם gcc -O0 -g test.c -o test - גם הכתובות היו זהות לחלוטין - היה אותו פלט בדיוק - אבל דווקא האסמבלי (החלק של הלולאה, כמובן) נראה טיפה שונה (משל eXtruct) ונראה כך:

קוד:

$ gdb ./test
GNU gdb 6.7.1
Copyright (C) 2007 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-pc-linux-gnu"...
Using host libthread_db library "/lib/libthread_db.so.1".
(gdb) disassemble main
Dump of assembler code for function main:
0x00000000004004b8 <main+0>:    push   %rbp
0x00000000004004b9 <main+1>:    mov    %rsp,%rbp
0x00000000004004bc <main+4>:    movl   $0x0,-0x4(%rbp)
0x00000000004004c3 <main+11>:   jmp    0x4004c8 <main+16>
0x00000000004004c5 <main+13>:   incl   -0x4(%rbp)
0x00000000004004c8 <main+16>:   cmpl   $0xa,-0x4(%rbp)
0x00000000004004cc <main+20>:   jne    0x4004c5 <main+13>
0x00000000004004ce <main+22>:   mov    $0x0,%eax
0x00000000004004d3 <main+27>:   leaveq
0x00000000004004d4 <main+28>:   retq
End of assembler dump.
(gdb)

מעניין...

כמו כן יש את העניין שב while אפשר לעשות שבלוק הקוד ירוץ פעם אחת ורק אז התנאי ייבדק - משהו שב for לא כל כך פשוט לעשות (לא אומר שבלתי אפשרי - פחות טריוויאלי...)

נמאס לכם לזכור סיסמאות? לחצו כאן!

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


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

[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://www.yarntomato.com/percentbarmaker/button.php?barPosition=90&leftFill=BBC7CE]

אכן הסבר מעולה

אני מכיר רק ASM-8051. את האסמבלי שהצגת קצת קשה לי להבין מאחר ואיני יודע מה זה DWORD, וגם השימוש ב-"<" ו- ">" או "[" ו-"]" לא מוכר לי.

אז השורה התחתונה - אין הבדל בין הלולאות האלו.

בעע סורי שלא עניתי הייתי עסוק ברשתות נירונים (רשתות עצבים, ANN)

talaus
אין מה לתקן אתה אכן צודק

dorM
הם ממקומים במקומות שונים כי כל הקוד של התוכנית נשמר בזיכרון כרצף פקודות, אי אפשר לשמור פקודה על פקודה כי היא תדרוס אותה, זה כמו מערך כאשר כל תא מציין פקודה מסויימת ב ASM.
DWORD זה DATA WORD, ברוב המחשבים של היום גודלו 32 סיביות (4ביתים) או במחשבים של 64BIT גודלו כמובן 64סיביות (8ביתים). הסוגריים הללו <> זה נראה לי סתם תוספת של הקומפיילר וה DISASSEMBLER. הסוגריים הללו [] הם גישה לתוכן שנמצא בכתובת ביניהם.

encoded
מסכים איתך 100%.

בחלק מה-DISASSEMBLER-ים יש פיצ'ר נחמד שמאפשר להציג ביטוי של הכתובות המצויות בפקודות. מה שמצוי בתוך ה-<> זה פשוט ביטוי נוח לכתובת שאליה קופצים (main+X משמע הכתובת של פונקצית ה-main ועוד X בתים).

עריכה: שמתי לב שניתן לראות זאת בבירור בדוגמת קוד שניתנה ע"י שימי, שווה שתסתכל.

[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://www.yarntomato.com/percentbarmaker/button.php?barPosition=90&leftFill=BBC7CE]

DWORD זה Double Word ולא "Data Word", כמו ש-QWORD זה Quad Word.
מילת מכונה (Word) ב-PC-ים היום היא 4 בתים (במעבדי 32-ביט) או 8 בתים (במעבדי 64-ביט), אבל המושגים נשארו מעידן מעבדי 16-ביט של אינטל, ולכן כשמדברים על גדלים Word בד"כ מציינת 2 בתים. לכן, DWORD מציינת 4 בתים - 2 מילות מכונה.

דוגמה מהקרנל של לינוקס:

קוד PHP:

 #define PRINT_LMIP_byte(_h, _lseq, _n)                              \
    asd_printk(STR_8BIT, #_n, LmSEQ_##_n(_lseq)-LmSCRATCH(_lseq), \
           asd_read_reg_byte(_h, LmSEQ_##_n(_lseq)))
#define PRINT_LMIP_word(_h, _lseq, _n)                              \
    asd_printk(STR_16BIT, #_n, LmSEQ_##_n(_lseq)-LmSCRATCH(_lseq), \
           asd_read_reg_word(_h, LmSEQ_##_n(_lseq)))
#define PRINT_LMIP_dword(_h, _lseq, _n)                             \
    asd_printk(STR_32BIT, #_n, LmSEQ_##_n(_lseq)-LmSCRATCH(_lseq), \
           asd_read_reg_dword(_h, LmSEQ_##_n(_lseq)))
#define PRINT_LMIP_qword(_h, _lseq, _n)                                \
    asd_printk(STR_64BIT, #_n, LmSEQ_##_n(_lseq)-LmSCRATCH(_lseq), \
         (unsigned long long)(((unsigned long long) \
         asd_read_reg_dword(_h, LmSEQ_##_n(_lseq))) \
              | (((unsigned long long) \
         asd_read_reg_dword(_h, LmSEQ_##_n(_lseq)+4))<<32))) 


ובווינדוס:

קוד PHP:

 typedef unsigned long DWORD, *PDWORD, *LPDWORD; 


ציטוט:

במקור נכתב על ידי eXtruct זה DATA WORD, ברוב המחשבים של היום גודלו 32 סיביות (4ביתים) או במחשבים של 64BIT גודלו כמובן 64סיביות (8ביתים).

ציטוט:

במקור נכתב על ידי rtasjugythhh מילת מכונה (Word) ב-PC-ים היום היא 4 בתים (במעבדי 32-ביט) או 8 בתים (במעבדי 64-ביט), אבל המושגים נשארו מעידן מעבדי 16-ביט של אינטל, ולכן כשמדברים על גדלים Word בד"כ מציינת 2 בתים. לכן, DWORD מציינת 4 בתים - 2 מילות מכונה.

אז זה יוצא נורא מבלבל...
כשכותבים WORD, לאיזה מהפירושים מתכוונים?
האם כאשר מתכונים למילת מכונה ממש (32 או 64, תלוי במעבד) יציינו זאת במפורש?

תודה לכולם