Apakah "untuk (;;)" lebih cepat dari "sementara (BENAR)"? Jika tidak, mengapa orang menggunakannya?

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

Saya telah melihat hal semacam ini banyak digunakan, tetapi saya pikir ini agak aneh ... Bukankah lebih jelas untuk mengatakannya while(true), atau sesuatu seperti itu?

Saya menduga bahwa (seperti alasan banyak programmer untuk menggunakan kode samar) ini adalah margin kecil lebih cepat?

Mengapa, dan apakah itu sangat berharga? Jika demikian, mengapa tidak mendefinisikannya seperti ini:

#define while(true) for(;;)

Lihat juga: Mana yang lebih cepat: while (1) atau while (2)?

1. Itu tidak lebih cepat.
2. Jika Anda benar-benar peduli, kompilasi dengan output assembler untuk platform Anda dan lihat untuk melihat.
3. Itu tidak masalah. Ini tidak masalah. Tulis loop tak terbatas Anda sesuka Anda.

saya lebih memilih for(;;) karena dua alasan.

Salah satunya adalah bahwa beberapa kompiler menghasilkan peringatan while(true) (sesuatu seperti "kondisi loop konstan"). Menghindari peringatan selalu merupakan hal yang baik untuk dilakukan.

Lain adalah bahwa saya pikir for(;;)lebih jelas dan lebih jitu. Saya ingin loop tanpa batas. Secara harfiah memiliki tidak kondisi, itu tidak bergantung pada apa pun. Saya hanya ingin itu berlanjut selamanya, sampai saya melakukan sesuatu untuk keluar darinya.

Padahal dengan while(true) , yah, apa yang sebenarnya harus dilakukan dengan apa pun? Saya tidak tertarik pada perulangan sampai benar menjadi salah, yang secara formal dikatakan oleh bentuk ini (perulangan sementara benar adalah benar). Saya hanya ingin mengulang.

Dan tidak, sama sekali tidak ada perbedaan kinerja.

Secara pribadi saya menggunakan for (;;)karena tidak ada angka di dalamnya, itu hanya kata kunci. Saya lebih suka untuk while (true), while (1), while (42), while (!0)dll dll

Karena Dennis Ritchie

• Saya mulai menggunakan for (;;)karena itulah yang dilakukan Dennis Ritchie di K&R, dan ketika belajar bahasa baru saya selalu mencoba meniru orang-orang pintar.

• Ini adalah C / C ++ idiomatik. Ini mungkin lebih baik dalam jangka panjang untuk terbiasa jika Anda berencana untuk melakukan banyak hal di ruang C / C ++.

• Anda #define tidak akan berfungsi, karena hal yang menjadi # define harus terlihat seperti pengidentifikasi C.

• Semua kompiler modern akan menghasilkan kode yang sama untuk kedua konstruk tersebut.

Ini tentu tidak lebih cepat di kompiler waras. Keduanya akan dikompilasi menjadi lompatan tanpa syarat. Untuk versi lebih mudah untuk mengetik (seperti kata Neil) dan akan menjadi jelas jika Anda mengerti sintaks loop.

Jika Anda penasaran, inilah yang diberikan gcc 4.4.1 kepada saya untuk x86. Keduanya menggunakan instruksi x86 JMP .

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

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

mengkompilasi ke (sebagian):

.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

saya lebih memilih for (;;) karena ini paling konsisten di berbagai bahasa mirip-C.

Dalam C ++ while (true)baik-baik saja, tetapi dalam C Anda bergantung pada header untuk didefinisikan true, namun TRUEjuga makro yang umum digunakan. Jika Anda menggunakannya while (1)benar dalam C dan C ++, dan JavaScript, tetapi bukan Java atau C #, yang mengharuskan kondisi loop menjadi boolean, seperti while (true)atau while (1 == 1). Dalam PHP, kata kunci tidak peka huruf besar-kecil tetapi bahasanya lebih suka huruf besarTRUE .

Namun, for (;;)selalu sepenuhnya benar dalam semua bahasa tersebut.

Saya pribadi lebih suka for (;;)idiom (yang akan dikompilasi dengan kode yang sama denganwhile (TRUE) .

Menggunakan while (TRUE)mungkin lebih mudah dibaca di satu sisi, saya telah memutuskan untuk menggunakan for (;;)idiom karena menonjol .

Konstruk infinite loop harus mudah dilihat atau dipanggil dalam kode, dan saya pribadi berpendapat bahwa for (;;)style ini sedikit lebih baik daripada while (TRUE)atauwhile (1) .

Juga, saya ingat bahwa beberapa kompiler mengeluarkan peringatan ketika ekspresi pengontrol loop sementara adalah konstan. Saya tidak berpikir itu terjadi terlalu banyak, tetapi hanya potensi peringatan palsu sudah cukup bagi saya untuk ingin menghindarinya.

Saya telah melihat beberapa orang lebih menyukainya karena mereka memiliki #define di suatu tempat seperti ini:

#define EVER ;;

Yang memungkinkan mereka untuk menulis ini:

for (EVER)
{
    /* blah */
}

Bagaimana dengan (jika bahasa Anda mendukungnya):

start:
/* BLAH */
goto start;

Tidak ada perbedaan dalam hal kode mesin yang dihasilkan.

Namun, hanya untuk melawan tren, saya berpendapat bahwa bentuk sementara (BENAR) jauh lebih mudah dibaca dan intuitif daripada untuk; Saya telah mendengar untuk pendekatan for (;;) (Saya lebih suka mendasarkan pedoman pengkodean saya pada alasan yang kuat dan / atau bukti keefektifan diri saya sendiri).

Bukan hanya pola yang terkenal, tetapi idiom standar dalam C (dan C ++)

while(true)

menghasilkan peringatan dengan Visual Studio (kondisinya konstan). Sebagian besar tempat saya bekerja mengkompilasi build produksi dengan peringatan sebagai kesalahan. Begitu

for(;;)

lebih disukai.

Keduanya harus sama jika kode Anda dioptimalkan oleh kompiler. Untuk menjelaskan apa yang saya maksud dengan optimasi, berikut ini contoh kode yang ditulis dalam MSVC 10:

int x = 0;

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

    printf("%d", x);
}

Jika Anda membangunnya dalam mode Debug ( tanpa optimasi apa pun (/ Od) ) pembongkaran menunjukkan perbedaan yang jelas. Ada instruksi tambahan untuk truekondisi di dalam while.

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)  

Namun, jika Anda membuat kode dalam mode Rilis (dengan Kecepatan Maksimalkan default (/ O2) ) Anda mendapatkan output yang sama untuk keduanya. Kedua loop dikurangi menjadi satu instruksi lompatan.

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)  

Apa pun yang akan Anda gunakan tidak masalah untuk kompiler yang layak dengan optimisasi kecepatan aktif.

Ini masalah preferensi pribadi mana yang lebih cepat. Secara pribadi, saya seorang touchtypist dan tidak pernah melihat keyboard saya, selama pemrograman - saya dapat menyentuh semua 104 tombol pada keyboard saya.

Saya menemukan jika lebih cepat mengetik "while (TRUE)".

Saya secara mental menambahkan beberapa pengukuran gerakan jari dan menjumlahkannya. "for (;;)" memiliki sekitar 12 lebar tombol dari gerakan ke belakang dan keempat (antara tombol beranda dan tombol, dan antara tombol beranda dan tombol SHIFT) "sementara (TRUE)" memiliki sekitar 14 lebar tombol gerakan ke belakang dan ke belakang. keempat.

Namun, saya jauh lebih rentan kesalahan saat mengetik yang terakhir. Saya secara mental berpikir dalam kata-kata pada suatu waktu, jadi saya merasa lebih cepat untuk mengetik hal-hal seperti "nIndex" daripada akronim seperti "nIdx" karena saya harus benar-benar secara mental mengeja huruf daripada berbicara di dalam pikiran saya dan membiarkan jari-jari saya otomatis -tip kata (seperti naik sepeda)

(Patokan TypingTest.com saya = 136 WPM)

Semua jawaban yang baik - perilaku harus persis sama.

NAMUN - Anggap saja APA membuat perbedaan. Misalkan salah satu dari mereka mengambil 3 instruksi lagi per iterasi.

Haruskah kamu peduli?

HANYA jika apa yang Anda lakukan di dalam loop hampir tidak ada , yang hampir tidak pernah terjadi.

Maksud saya adalah, ada optimasi mikro dan optimasi makro. Optimalisasi mikro seperti "memotong rambut untuk menurunkan berat badan".

Saya tidak dapat membayangkan bahwa kompiler yang berharga akan menghasilkan kode yang berbeda. Bahkan jika itu terjadi, tidak akan ada cara untuk menentukan tanpa menguji kompiler tertentu yang lebih efisien.

Namun saya sarankan Anda lebih suka for(;;)karena alasan berikut:

• sejumlah kompiler yang saya gunakan akan menghasilkan peringatan ekspresi konstan untuk sementara (benar) dengan pengaturan tingkat peringatan yang sesuai.

• dalam contoh Anda, makro yang BENAR mungkin tidak didefinisikan seperti yang Anda harapkan

• ada banyak kemungkinan varian terbatas sementara lingkaran seperti while(1), while(true), while(1==1)dll .; sehingga for(;;)cenderung menghasilkan konsistensi yang lebih besar.

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

Lebih jelas dari:

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

Bukan berarti ini berlaku jika Anda tidak menggunakan Sleep().

Loop "selamanya" populer di sistem embedded sebagai loop latar belakang. Beberapa orang menerapkannya sebagai:

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

Dan terkadang itu diimplementasikan sebagai:

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

Dan implementasi lain adalah:

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

Kompiler pengoptimalisasi harus menghasilkan kode perakitan yang sama atau serupa untuk fragmen ini. Satu catatan penting: waktu eksekusi untuk loop bukan masalah besar karena loop ini berlangsung selamanya, dan lebih banyak waktu dihabiskan di bagian pemrosesan.

Saya berasumsi while (true) lebih mudah dibaca daripada for (;;) - sepertinya programmer melewatkan sesuatu untuk loop :)

Alasan paling penting untuk menggunakan "for (;;)" adalah ketakutan untuk menggunakan "while (TRUE)" ketika Anda melakukan pemrograman eksplorasi. Lebih mudah untuk mengontrol jumlah pengulangan dengan "untuk", dan juga, lebih mudah untuk mengubah loop "untuk" menjadi tak terbatas.

Misalnya, jika Anda membuat fungsi rekursif, Anda dapat membatasi jumlah panggilan ke fungsi sebelum mengubahnya menjadi loop tak terbatas.

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

Ketika saya yakin dengan fungsi saya, maka saya mengonversinya menjadi loop tanpa batas:

    for(;;) recursiveFunction(oneParam);