“ สำหรับ (;;)” เร็วกว่า“ ขณะ (TRUE)” หรือไม่ ถ้าไม่ทำไมผู้คนถึงใช้มัน?

for (;;) {
    //Something to be done repeatedly
}

ฉันเคยเห็นสิ่งต่าง ๆ นี้ใช้บ่อย แต่ฉันคิดว่ามันค่อนข้างแปลก ... มันจะไม่ชัดเจนกว่าที่จะพูดwhile(true)หรือบางสิ่งบางอย่างตามสายเหล่านั้น?

ฉันเดาว่า (เช่นเดียวกับเหตุผลที่โปรแกรมเมอร์หลายคนหันไปใช้รหัสลับ) นี่เป็นอัตรากำไรขั้นต้นที่น้อยกว่าหรือไม่

ทำไมและมันคุ้มค่าจริงหรือ ถ้าเป็นเช่นนั้นทำไมไม่กำหนดเพียงวิธีนี้:

#define while(true) for(;;)

ดูเพิ่มเติม: อันไหนเร็วกว่าในขณะที่ (1) หรือขณะที่ (2)?

1. มันไม่เร็ว
2. หากคุณสนใจจริงๆให้คอมไพล์ด้วยแอสเซมเบลอร์เอาท์พุทสำหรับแพลตฟอร์มของคุณและดู
3. มันไม่สำคัญ สิ่งนี้ไม่สำคัญ เขียนลูปไม่มีที่สิ้นสุดของคุณตามที่คุณต้องการ

ฉันชอบfor(;;)ด้วยเหตุผลสองประการ

หนึ่งคือคอมไพเลอร์บางคนสร้างคำเตือนwhile(true)(เช่น "สภาพลูปเป็นค่าคงที่") การหลีกเลี่ยงคำเตือนเป็นสิ่งที่ควรทำ

อีกอย่างคือฉันคิดว่าfor(;;)ชัดเจนและบอกได้มากกว่า ฉันต้องการวงวนไม่สิ้นสุด แท้จริงมันมีสภาพไม่ก็ขึ้นอยู่กับอะไร ฉันแค่อยากให้มันดำเนินต่อไปตลอดไปจนกว่าฉันจะทำอะไรสักอย่างเพื่อแยกมันออกมา

ในขณะที่มีwhile(true)ดีสิ่งที่มีจริงจะทำอย่างไรกับอะไร? ฉันไม่สนใจที่จะวนซ้ำจนกว่าความจริงจะกลายเป็นเท็จซึ่งเป็นสิ่งที่แบบฟอร์มนี้พูดอย่างแท้จริง (วนซ้ำในขณะที่ความจริงเป็นจริง) ฉันแค่ต้องการวนซ้ำ

และไม่ไม่มีความแตกต่างด้านประสิทธิภาพอย่างแน่นอน

ส่วนตัวฉันใช้for (;;)เพราะไม่มีตัวเลขใด ๆ มันเป็นเพียงคำหลัก ฉันชอบมันwhile (true), while (1), while (42), while (!0)ฯลฯ เป็นต้น

เพราะเดนนิสริตชี่

• ฉันเริ่มใช้for (;;)เพราะนั่นคือวิธีที่ Dennis Ritchie ทำใน K&R และเมื่อเรียนรู้ภาษาใหม่ฉันพยายามเลียนแบบพวกที่ฉลาด

• นี่คือสำนวน C / C ++ น่าจะดีกว่าในระยะยาวหากคุณคุ้นเคยกับการทำสิ่งต่างๆในพื้นที่ C / C ++

• คุณ#defineจะไม่ทำงานเนื่องจากสิ่งที่ # define'd ต้องดูเหมือนกับตัวระบุ C

• คอมไพเลอร์สมัยใหม่ทั้งหมดจะสร้างรหัสเดียวกันสำหรับการสร้างทั้งสอง

แน่นอนว่ามันจะไม่เร็วขึ้นในคอมไพเลอร์ที่มีสติ พวกเขาทั้งสองจะถูกรวบรวมไว้ในการกระโดดที่ไม่มีเงื่อนไข สำหรับเวอร์ชั่นนั้นง่ายกว่าในการพิมพ์ (ตามที่ Neil พูด) และจะชัดเจนหากคุณเข้าใจไวยากรณ์ลูป

หากคุณสงสัยนี่คือสิ่งที่ gcc 4.4.1 มอบให้ฉันสำหรับ x86 ทั้งคู่ใช้คำสั่งx86 JMP

void while_infinite()
{
    while(1)
    {
    puts("while");
    }
}

void for_infinite()
{
    for(;;)
    {
    puts("for");
    }
}

รวบรวมเป็น (บางส่วน):

.LC0:
.string "while"
.text
.globl while_infinite
    .type   while_infinite, @function
while_infinite:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $24, %esp
.L2:
    movl    $.LC0, (%esp)
    call    puts
    jmp .L2
    .size   while_infinite, .-while_infinite
    .section    .rodata
.LC1:
    .string "for"
    .text
.globl for_infinite
    .type   for_infinite, @function
for_infinite:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $24, %esp
.L5:
    movl    $.LC1, (%esp)
    call    puts
    jmp .L5
    .size   for_infinite, .-for_infinite

ฉันชอบfor (;;)เพราะมันสอดคล้องกันมากที่สุดในภาษา C ที่แตกต่างกัน

ใน C ++ while (true)นั้นใช้ได้ แต่ใน C คุณขึ้นอยู่กับส่วนหัวที่จะกำหนดtrueแต่TRUEเป็นมาโครที่ใช้กันทั่วไป ถ้าคุณใช้while (1)มันถูกต้องใน C และ C ++ และ JavaScript แต่ไม่ Java หรือ C # ซึ่งต้องห่วงสภาพที่จะเป็นแบบบูลเช่นหรือwhile (true) while (1 == 1)ใน PHP คำหลักกรณีตาย TRUEแต่ภาษาที่ชอบเป็นทุน

อย่างไรก็ตามfor (;;)ถูกต้องเสมอในทุกภาษาเหล่านั้น

ผมเองชอบfor (;;)สำนวน while (TRUE)(ซึ่งจะรวบรวมรหัสเดียวกับ

ใช้while (TRUE)อาจจะอ่านได้มากขึ้นในอีกแง่หนึ่งฉันได้ตัดสินใจที่จะใช้for (;;)สำนวนเพราะมันยืนออก

สร้างห่วงอนันต์ควรจะสังเกตเห็นได้ง่ายหรือเรียกว่าออกมาในรหัสและผมเองคิดว่าfor (;;)สไตล์ไม่นี้บิตดีกว่าหรือwhile (TRUE)while (1)

นอกจากนี้ฉันยังจำได้ว่าคอมไพเลอร์บางคนออกคำเตือนเมื่อนิพจน์การควบคุมของลูป while นั้นเป็นค่าคงที่ ฉันไม่คิดว่ามันจะเกิดขึ้นมากเกินไป แต่แค่ศักยภาพในการเตือนปลอมเท่านั้นที่เพียงพอสำหรับฉันที่จะต้องการหลีกเลี่ยง

ฉันเคยเห็นบางคนชอบเพราะมี #define บางแห่งเช่นนี้:

#define EVER ;;

ซึ่งทำให้พวกเขาเขียนสิ่งนี้:

for (EVER)
{
    /* blah */
}

เกี่ยวกับ (ถ้าภาษาของคุณรองรับ):

start:
/* BLAH */
goto start;

ไม่มีความแตกต่างในแง่ของรหัสเครื่องที่สร้างขึ้น

อย่างไรก็ตามเพื่อให้เป็นไปตามแนวโน้มฉันขอยืนยันว่ารูปแบบในขณะที่ (TRUE) สามารถอ่านและเข้าใจได้ง่ายกว่าสำหรับ (;;) และความสามารถในการอ่านและความคมชัดนั้นเป็นเหตุผลสำคัญสำหรับการเข้ารหัสแนวทางมากกว่าเหตุผลใด ๆ ฉันเคยได้ยินเกี่ยวกับวิธีการ (;;) (ฉันชอบที่จะใช้แนวทางการเข้ารหัสของฉันในการให้เหตุผลที่มั่นคงและ / หรือการพิสูจน์ประสิทธิภาพของตัวเอง)

ไม่ใช่แค่รูปแบบที่รู้จักกันดี แต่เป็นสำนวนมาตรฐานใน C (และ C ++)

while(true)

สร้างคำเตือนด้วย Visual Studio (เงื่อนไขเป็นค่าคงที่) สถานที่ส่วนใหญ่ที่ฉันได้ทำงานรวบรวมการผลิตสร้างด้วยคำเตือนเป็นข้อผิดพลาด ดังนั้น

for(;;)

เป็นที่ต้องการ

ทั้งคู่ควรเหมือนกันถ้าคอมไพเลอร์ของคุณได้รับการปรับให้เหมาะสม เพื่ออธิบายสิ่งที่ฉันหมายถึงโดยการเพิ่มประสิทธิภาพนี่คือตัวอย่างรหัสที่เขียนใน MSVC 10:

int x = 0;

while(true) // for(;;)
{
    x +=1;

    printf("%d", x);
}

ถ้าคุณสร้างมันในโหมดดีบั๊ก ( โดยไม่มีการปรับแต่งใด ๆ (/ Od) ) แสดงความแตกต่างที่ชัดเจน มีคำแนะนำพิเศษสำหรับการเป็นภายในสภาพtruewhile

while(true)
00D313A5  mov         eax,1                //extra 
00D313AA  test        eax,eax              //extra
00D313AC  je          main+39h (0D313B9h)  //extra
    {
        x +=1;
00D313AE  mov         eax,dword ptr [x]  
00D313B1  add         eax,1  
00D313B4  mov         dword ptr [x],eax  
    printf("%d", x);
    ...
    }
00D313B7  jmp         main+25h (0D313A5h)  


for(;;)
    {
        x +=1;
00D213A5  mov         eax,dword ptr [x]  
00D213A8  add         eax,1  
00D213AB  mov         dword ptr [x],eax  
    printf("%d", x);
    ...
    }
00D213AE  jmp         main+25h (0D213A5h)  

อย่างไรก็ตามหากคุณสร้างรหัสในโหมด Release (โดยค่าเริ่มต้น ความเร็วสูงสุด (/ O2) ) คุณจะได้ผลลัพธ์เดียวกันทั้งคู่ ลูปทั้งสองจะลดลงเป็นคำสั่งกระโดดหนึ่งครั้ง

for(;;)
    {
        x +=1;
01291010  inc         esi  

        printf("%d", x);
    ...
    }
0129101C  jmp         main+10h (1291010h)  

    while(true)
    {
        x +=1;
00311010  inc         esi  

        printf("%d", x);
    ...
    }
0031101C  jmp         main+10h (311010h)  

ไม่ว่าคุณจะใช้งานแบบใดก็ตามไม่ว่าจะเป็นคอมไพเลอร์ที่ดีพร้อมการเพิ่มประสิทธิภาพความเร็วก็ตาม

มันเป็นเรื่องของความชอบส่วนตัวซึ่งเป็นวิธีที่เร็วกว่า โดยส่วนตัวแล้วฉันเป็นนักออกแบบระบบสัมผัสและไม่เคยดูที่แป้นพิมพ์ของฉันในระหว่างการเขียนโปรแกรม - ฉันสามารถใช้แป้นพิมพ์ทั้ง 104 ปุ่มบนแป้นพิมพ์ได้

ฉันพบว่าพิมพ์เร็วกว่า "ในขณะที่ (จริง)"

ฉันเพิ่มการวัดการเคลื่อนไหวนิ้วของจิตใจและรวมพวกมันเข้าด้วยกัน "for (;;)" มีความกว้างประมาณ 12 คีย์ของการเคลื่อนไหวไปมาและหลังที่สี่ (ระหว่างปุ่มโฮมและปุ่มและระหว่างปุ่มโฮมและปุ่ม SHIFT) "ในขณะที่ (TRUE)" มีความกว้างประมาณ 14 คีย์ของการเคลื่อนไหวกลับและ ที่สี่

อย่างไรก็ตามฉันมีข้อผิดพลาดน้อยลงอย่างมากเมื่อพิมพ์หลัง ฉันคิดในใจด้วยคำพูดในแต่ละครั้งดังนั้นฉันจึงพบว่ามันเร็วกว่าในการพิมพ์สิ่งต่าง ๆ เช่น "nIndex" มากกว่าตัวย่อเช่น "nIdx" เพราะฉันต้องสะกดจิตตัวอักษรมากกว่าพูดในใจและปล่อยให้อัตโนมัติ - พิมพ์คำ (เช่นขี่จักรยาน)

(เกณฑ์มาตรฐาน TypingTest.com ของฉัน = 136 WPM)

คำตอบที่ดีทั้งหมด - พฤติกรรมควรเหมือนกันทุกประการ

อย่างไร - เพียงแค่สมมติว่ามันสร้างความแตกต่าง สมมติว่าหนึ่งในนั้นใช้คำแนะนำเพิ่มเติม 3 คำต่อการวนซ้ำ

คุณควรสนใจไหม

ถ้าสิ่งที่คุณทำในลูปนั้นแทบจะไม่มีอะไรเลยซึ่งแทบจะไม่เกิดเลย

จุดของฉันคือมีการเพิ่มประสิทธิภาพขนาดเล็กและการเพิ่มประสิทธิภาพแมโคร การเพิ่มประสิทธิภาพขนาดเล็กเป็นเหมือน "การตัดผมเพื่อลดน้ำหนัก"

ฉันไม่สามารถจินตนาการได้ว่าคอมไพเลอร์ที่คุ้มค่าจะสร้างรหัสที่แตกต่างกัน แม้ว่ามันจะเป็นเช่นนั้นก็จะไม่มีวิธีการพิจารณาโดยไม่ต้องทดสอบคอมไพเลอร์เฉพาะที่มีประสิทธิภาพมากขึ้น

อย่างไรก็ตามฉันขอแนะนำให้คุณชอบfor(;;)ด้วยเหตุผลดังต่อไปนี้:

• คอมไพเลอร์จำนวนหนึ่งที่ฉันใช้จะสร้างคำเตือนนิพจน์คงที่ในขณะที่ (จริง) พร้อมการตั้งค่าระดับคำเตือนที่เหมาะสม

• ในตัวอย่างของคุณมาโคร TRUE อาจไม่ได้รับการกำหนดตามที่คุณคาดหวัง

• มีสายพันธุ์ที่เป็นไปได้หลายที่ไม่มีที่สิ้นสุดในขณะที่ห่วงเช่นwhile(1), while(true), while(1==1)ฯลฯ .; ดังนั้นfor(;;)มีแนวโน้มที่จะส่งผลให้ความมั่นคงมากขึ้น

for(;;Sleep(50))
{
    // Lots of code
}

ชัดเจนกว่า:

while(true)
{
    // Lots of code
    Sleep(50);
}

Sleep()ไม่ว่านี้ถ้าคุณไม่ได้ใช้

วนรอบ "ตลอดไป" เป็นที่นิยมในระบบฝังตัวเป็นวนรอบด้านหลัง บางคนใช้มันเป็น:

for (; ;)
{
 // Stuff done in background loop
}

และบางครั้งมันถูกนำไปใช้เป็น:

while (TRUE /* or use 1 */)
{
 // Stuff done in background loop
}

และการดำเนินการอื่นคือ:

do
{
 // Stuff done in background loop
} while (1 /* or TRUE */);

คอมไพเลอร์การปรับให้เหมาะสมควรสร้างรหัสแอสเซมบลีที่เหมือนกันหรือคล้ายกันสำหรับแฟรกเมนต์เหล่านี้ สิ่งสำคัญประการหนึ่ง: เวลาดำเนินการของลูปนั้นไม่ได้เป็นปัญหาใหญ่นักเนื่องจากลูปเหล่านี้ดำเนินต่อไปตลอดกาลและใช้เวลามากขึ้นในส่วนการประมวลผล

ฉันคิดว่าในขณะที่ (จริง) สามารถอ่านได้มากกว่าสำหรับ (;;) - ดูเหมือนว่าโปรแกรมเมอร์พลาดอะไรบางอย่างในวง :)

เหตุผลที่สำคัญที่สุดในการใช้ "for (;;)" คือความกลัวในการใช้ "while (TRUE)" เมื่อคุณทำการเขียนโปรแกรมเชิงสำรวจ มันง่ายกว่าที่จะควบคุมปริมาณการทำซ้ำด้วย "สำหรับ" และยังง่ายกว่าในการแปลงลูป "for" เป็นอนันต์

ตัวอย่างเช่นหากคุณกำลังสร้างฟังก์ชั่นวนซ้ำคุณสามารถ จำกัด จำนวนการเรียกไปยังฟังก์ชันก่อนที่จะแปลงเป็นลูปไม่สิ้นสุด

    for(int i=0;i<1000;i++) recursiveFunction(oneParam);

เมื่อฉันแน่ใจว่าฟังก์ชั่นของฉันแล้วฉันจะแปลงเป็นวงไม่สิ้นสุด:

    for(;;) recursiveFunction(oneParam);