Haruskah seseorang menggunakan <atau <= dalam for for [ditutup]


124

Jika Anda harus mengulang melalui loop sebanyak 7 kali, apakah Anda akan menggunakan:

for (int i = 0; i < 7; i++)

atau:

for (int i = 0; i <= 6; i++)

Ada dua pertimbangan:

  • kinerja
  • keterbacaan

Untuk kinerja saya mengasumsikan Java atau C #. Apakah penting jika "kurang dari" atau "kurang dari atau sama dengan" digunakan? Jika Anda memiliki wawasan untuk bahasa yang berbeda, harap tunjukkan mana.

Untuk keterbacaan, saya mengasumsikan array berbasis 0.

UPD: Penyebutan saya tentang array berbasis 0 mungkin membingungkan. Saya tidak berbicara tentang iterasi melalui elemen array. Hanya lingkaran umum.

Ada poin bagus di bawah ini tentang menggunakan konstanta yang akan menjelaskan apa angka ajaib ini. Jadi jika saya " int NUMBER_OF_THINGS = 7" maka " i <= NUMBER_OF_THINGS - 1" akan terlihat aneh, bukan.


saya akan mengatakan: jika Anda dijalankan melalui seluruh array, jangan pernah kurangi atau tambahkan angka apa pun ke sisi kiri.
Letterman

Jawaban:


287

Yang pertama lebih idiomatis . Secara khusus, ini menunjukkan (dalam arti berbasis 0) jumlah iterasi. Saat menggunakan sesuatu berbasis 1 (misalnya JDBC, IIRC) saya mungkin tergoda untuk menggunakan <=. Begitu:

for (int i=0; i < count; i++) // For 0-based APIs

for (int i=1; i <= count; i++) // For 1-based APIs

Saya berharap perbedaan kinerja menjadi tidak signifikan dalam kode dunia nyata.


30
Anda hampir dijamin tidak akan ada perbedaan kinerja. Banyak arsitektur, seperti x86, memiliki instruksi "melompat kurang dari atau sama dalam perbandingan terakhir". Cara yang paling mungkin Anda akan melihat perbedaan kinerja adalah dalam beberapa jenis bahasa yang ditafsirkan yang diimplementasikan dengan buruk.
Wedge

3
Apakah Anda akan mempertimbangkan menggunakan! = Sebagai gantinya? Saya akan mengatakan bahwa yang paling jelas menetapkan saya sebagai penghitung lingkaran dan tidak ada yang lain.
yungchin

21
Biasanya tidak. Itu terlalu asing. Ini juga berisiko masuk ke loop yang sangat, sangat panjang jika seseorang secara tidak sengaja menambah saya selama loop tersebut.
Jon Skeet

5
Pemrograman generik dengan STL iterators mengamanatkan penggunaan! =. Itu (peningkatan ganda tidak disengaja) tidak menjadi masalah bagi saya. Saya setuju bahwa untuk indeks <(atau> untuk turun) lebih jelas dan konvensional.
Jonathan Graehl

2
Ingat, jika Anda mengulangi Panjang array menggunakan <, JIT mengoptimalkan akses array (menghapus pemeriksaan terikat). Jadi harus lebih cepat menggunakan <=. Saya belum memeriksanya
konfigurator

72

Kedua loop tersebut berulang sebanyak 7 kali. Saya akan mengatakan yang satu dengan 7 di dalamnya lebih mudah dibaca / lebih jelas, kecuali Anda memiliki alasan yang benar-benar bagus untuk yang lain.


Saya ingat ketika saya mulai belajar Java. Saya benci konsep indeks berbasis 0 karena saya selalu menggunakan indeks berbasis 1. Jadi saya akan selalu menggunakan varian <= 6 (seperti yang ditunjukkan dalam pertanyaan). Sungguh merugikan saya sendiri, karena itu akan membingungkan saya pada akhirnya ketika for for loop benar-benar keluar. Lebih mudah menggunakan <
James Haug

55

Saya ingat dari hari-hari saya ketika kami melakukan Majelis 8086 di kampus, itu lebih baik dilakukan:

for (int i = 6; i > -1; i--)

karena ada operasi JNS yang berarti Langsung jika Tidak Ada Tanda. Menggunakan ini berarti bahwa tidak ada pencarian memori setelah setiap siklus untuk mendapatkan nilai perbandingan dan tidak ada perbandingan. Saat ini sebagian besar kompiler mengoptimalkan penggunaan register sehingga hal memori tidak lagi penting, tetapi Anda masih mendapatkan perbandingan yang tidak diperlukan.

By the way menempatkan 7 atau 6 di lingkaran Anda memperkenalkan " angka ajaib ". Untuk keterbacaan yang lebih baik, Anda harus menggunakan konstanta dengan Nama Pengungkapan Intent. Seperti ini:

const int NUMBER_OF_CARS = 7;
for (int i = 0; i < NUMBER_OF_CARS; i++)

EDIT: Orang-orang tidak mendapatkan hal perakitan sehingga jelas diperlukan contoh yang lebih lengkap:

Jika kita lakukan untuk (i = 0; i <= 10; i ++) Anda perlu melakukan ini:

    mov esi, 0
loopStartLabel:
                ; Do some stuff
    inc esi
                ; Note cmp command on next line
    cmp esi, 10
    jle exitLoopLabel
    jmp loopStartLabel
exitLoopLabel:

Jika kita lakukan untuk (int i = 10; i> -1; i--) maka Anda bisa lolos dengan ini:

    mov esi, 10
loopStartLabel:
                ; Do some stuff
    dec esi
                ; Note no cmp command on next line
    jns exitLoopLabel
    jmp loopStartLabel
exitLoopLabel:

Saya baru saja memeriksa dan kompiler C ++ Microsoft tidak melakukan optimasi ini, tetapi ia melakukannya jika Anda melakukannya:

for (int i = 10; i >= 0; i--) 

Jadi moralnya adalah jika Anda menggunakan Microsoft C ++ †, dan naik atau turun tidak ada bedanya, untuk mendapatkan perulangan cepat Anda harus menggunakan:

for (int i = 10; i >= 0; i--)

daripada salah satu dari ini:

for (int i = 10; i > -1; i--)
for (int i = 0; i <= 10; i++)

Tapi terus terang mendapatkan keterbacaan "untuk (int i = 0; i <= 10; i ++)" biasanya jauh lebih penting daripada melewatkan satu perintah prosesor.

† Kompiler lain dapat melakukan hal yang berbeda.


4
Kasus "angka ajaib" menggambarkan dengan baik, mengapa biasanya lebih baik menggunakan <daripada <=.
Rene Saarsoo

11
Versi lain adalah "untuk (int i = 10; i--;)". Beberapa orang menggunakan "for (int i = 10; i -> 0;)" dan berpura-pura bahwa kombinasi -> berarti menuju.
Zayenz

2
+1 untuk kode perakitan
neuro

1
tetapi ketika tiba saatnya untuk benar-benar menggunakan penghitung loop, misalnya untuk pengindeksan array, maka Anda perlu melakukan 7-iyang akan membanjiri optimasi yang Anda dapatkan dari menghitung mundur.
Lie Ryan

@ Lie, ini hanya berlaku jika Anda perlu memproses item dalam urutan maju. Dengan sebagian besar operasi dalam loop semacam ini, Anda dapat menerapkannya pada item dalam loop dalam urutan apa pun yang Anda suka. Misalnya, jika Anda mencari nilai, tidak masalah jika Anda mulai dari akhir daftar dan bekerja naik atau pada awal daftar dan menghitung turun (dengan asumsi Anda tidak dapat memprediksi ujung daftar barang Anda) mungkin dan caching memori tidak menjadi masalah).
Martin Brown

27

Saya selalu menggunakan <array.length karena lebih mudah dibaca daripada <= array.length-1.

juga memiliki <7 dan mengingat bahwa Anda tahu itu dimulai dengan indeks 0 itu harus intuitif bahwa angka adalah jumlah iterasi.


Anda harus selalu berhati-hati untuk memeriksa biaya fungsi Panjang saat menggunakannya dalam satu lingkaran. Sebagai contoh jika Anda menggunakan strlen di C / C ++ Anda akan secara besar-besaran meningkatkan waktu yang diperlukan untuk melakukan perbandingan. Ini karena strlen harus mengulang seluruh string untuk menemukan jawabannya yang mungkin hanya ingin Anda lakukan sekali daripada untuk setiap iterasi dari loop Anda.
Martin Brown

2
@ Martin Brown: di Jawa (dan saya percaya C #), String.length dan Array.length adalah konstan karena String tidak dapat diubah dan Array memiliki panjang tidak berubah. Dan karena String.length dan Array.length adalah bidang (alih-alih pemanggilan fungsi), Anda dapat yakin bahwa mereka harus O (1). Dalam kasus C ++, mengapa Anda menggunakan C-string?
Lie Ryan

18

Dilihat dari sudut pandang optimalisasi, itu tidak masalah.

Dilihat dari sudut pandang gaya kode saya lebih suka <. Alasan:

for ( int i = 0; i < array.size(); i++ )

jauh lebih mudah dibaca daripada

for ( int i = 0; i <= array.size() -1; i++ )

juga <memberi Anda jumlah iterasi langsung.

Pilihan lain untuk <adalah bahwa Anda dapat mencegah banyak kesalahan tidak disengaja satu demi satu.


10

@ Chris, Pernyataan Anda tentang. Panjang menjadi mahal di. NET sebenarnya tidak benar dan dalam kasus tipe sederhana kebalikannya.

int len = somearray.Length;
for(i = 0; i < len; i++)
{
  somearray[i].something();
}

sebenarnya lebih lambat dari

for(i = 0; i < somearray.Length; i++)
{
  somearray[i].something();
}

Nanti adalah kasus yang dioptimalkan oleh runtime. Karena runtime dapat menjamin saya adalah indeks yang valid ke dalam array tidak ada pemeriksaan batas yang dilakukan. Dalam yang pertama, runtime tidak dapat menjamin bahwa saya tidak dimodifikasi sebelum loop dan memaksa batas memeriksa pada array untuk setiap pencarian indeks.


Dalam Java. Panjang mungkin mahal dalam beberapa kasus. stackoverflow.com/questions/6093537/for-loop-optimization karena panggilan ke .lenghtOR .size. Saya tidak yakin tetapi dan tidak percaya diri tetapi ingin memastikan saja.
Ravi Parekh

6

Itu tidak membuat perbedaan yang efektif dalam hal kinerja. Karena itu saya akan menggunakan mana yang lebih mudah untuk dipahami dalam konteks masalah yang Anda pecahkan.


5

Saya lebih memilih:

for (int i = 0; i < 7; i++)

Saya pikir itu lebih mudah diterjemahkan menjadi "iterasi melalui loop 7 kali".

Saya tidak yakin tentang implikasi kinerja - saya menduga ada perbedaan yang bisa dikompilasi.


4

Di Java 1.5 Anda bisa melakukannya

for (int i: myArray) {
    ...
}

jadi untuk kasus array Anda tidak perlu khawatir.


4

Saya tidak berpikir ada perbedaan kinerja. Bentuk kedua jelas lebih mudah dibaca, Anda tidak perlu mengurangi secara mental untuk menemukan nomor iterasi terakhir.

EDIT: Saya melihat orang lain tidak setuju. Bagi saya pribadi, saya suka melihat angka indeks aktual dalam struktur loop. Mungkin karena ini lebih mengingatkan pada 0..6sintaksis Perl , yang saya tahu setara dengan (0,1,2,3,4,5,6). Jika saya melihat angka 7, saya harus memeriksa operator di sebelahnya untuk melihat bahwa, pada kenyataannya, indeks 7 tidak pernah tercapai.


Itu tergantung apakah Anda berpikir bahwa "angka iterasi terakhir" lebih penting daripada "jumlah iterasi". Dengan API berbasis 0, mereka akan selalu berbeda dengan 1 ...
Jon Skeet

4

Saya akan mengatakan menggunakan versi "<7" karena itulah yang akan dibaca oleh sebagian besar orang - jadi jika orang membaca skim Anda dengan cepat, mereka mungkin menafsirkannya dengan salah.

Saya tidak akan khawatir tentang apakah "<" lebih cepat dari "<=", cukup dibaca.

Jika Anda ingin meningkatkan kecepatan, pertimbangkan hal berikut:

for (int i = 0; i < this->GetCount(); i++)
{
  // Do something
}

Untuk meningkatkan kinerja, Anda dapat mengaturnya kembali menjadi:

const int count = this->GetCount();
for (int i = 0; i < count; ++i)
{
  // Do something
}

Perhatikan penghapusan GetCount () dari loop (karena itu akan ditanyai dalam setiap loop) dan perubahan "i ++" menjadi "++ i".


Saya suka yang kedua lebih baik karena lebih mudah dibaca tetapi apakah itu benar-benar menghitung ulang ini-> GetCount () setiap kali? Saya telah terperangkap oleh ini ketika mengubah ini dan jumlah tetap sama memaksa saya untuk melakukan do..saat ini-> GetCount ()
osp70

GetCount () akan dipanggil setiap iterasi dalam contoh pertama. Itu hanya akan dipanggil sekali dalam contoh kedua. Jika Anda memerlukan GetCount () untuk dipanggil setiap saat, maka periksakan di dalam lingkaran, jika Anda tidak mencoba menyimpannya di luar.
Tandai Ingram

Ya saya sudah mencobanya dan Anda benar, permintaan maaf saya.
osp70

Apa bedanya menggunakan ++ i over i ++?
Rene Saarsoo

Peningkatan kecepatan kecil saat menggunakan int, tetapi peningkatannya bisa lebih besar jika Anda menambah kelas Anda sendiri. Pada dasarnya ++ saya menambah nilai aktual, lalu mengembalikan nilai aktual. i ++ membuat temp var, menambahkan var nyata, lalu mengembalikan temp. Tidak diperlukan pembuatan var dengan ++ i.
Tandai Ingram

4

Dalam C ++, saya lebih suka menggunakan !=, yang dapat digunakan dengan semua wadah STL. Tidak semua iterator wadah STL kurang sebanding.


Ini sedikit membuatku takut hanya karena ada sedikit peluang di luar bahwa sesuatu mungkin akan mengulangi penghitung atas nilai yang saya maksudkan yang kemudian menjadikan ini loop tak terbatas. Kemungkinannya jauh dan mudah dideteksi - tetapi < terasa lebih aman.
Rob Allen

2
Jika ada bug seperti itu dalam kode Anda, mungkin lebih baik menabrak dan membakar daripada melanjutkan secara diam-diam :-)

Ini adalah jawaban yang tepat: ini mengurangi permintaan pada iterator Anda dan lebih mungkin muncul jika ada kesalahan dalam kode Anda. Argumen untuk <berpandangan pendek. Mungkin loop tak terbatas akan kembali buruk di tahun 70-an ketika Anda membayar untuk waktu CPU. '! =' kecil kemungkinannya untuk menyembunyikan bug.
David Nehme

1
Looping over iterators adalah kasus yang sepenuhnya berbeda dari perulangan dengan penghitung. ! = sangat penting untuk iterator.
DJClayworth

4

Edsger Dijkstra menulis sebuah artikel tentang ini pada tahun 1982 di mana ia berpendapat untuk yang lebih rendah <= i <atas:

Ada bilangan alami terkecil. Pengecualian dari batas bawah —seperti dalam b) dan d) - memaksa untuk suatu urutan yang dimulai dari bilangan alami terkecil, batas bawah seperti yang disebutkan dalam bidang bilangan tidak wajar. Itu jelek, jadi untuk batas bawah kita lebih suka ≤ seperti pada a) dan c). Pertimbangkan sekarang, urutan-urutan yang dimulai dari bilangan alami terkecil: dimasukkannya batas atas akan memaksa yang terakhir menjadi tidak alami pada saat urutannya menyusut menjadi yang kosong. Itu jelek, jadi untuk batas atas kita lebih suka <seperti pada a) dan d). Kami menyimpulkan bahwa konvensi a) lebih disukai.


3

Pertama, jangan gunakan 6 atau 7.

Lebih baik digunakan:

int numberOfDays = 7;
for (int day = 0; day < numberOfDays ; day++){

}

Dalam hal ini lebih baik daripada menggunakan

for (int day = 0; day <= numberOfDays  - 1; day++){

}

Bahkan lebih baik (Java / C #):

for(int day = 0; day < dayArray.Length; i++){

}

Dan bahkan lebih baik (C #)

foreach (int day in days){// day : days in Java

}

Loop terbalik memang lebih cepat tetapi karena lebih sulit untuk dibaca (jika tidak oleh Anda oleh programmer lain), lebih baik untuk menghindari. Terutama di C #, Java ...


2

Saya setuju dengan kerumunan yang mengatakan bahwa 7 masuk akal dalam kasus ini, tetapi saya akan menambahkan bahwa dalam kasus di mana 6 penting, katakan Anda ingin menjelaskan Anda hanya bertindak pada objek hingga indeks 6, maka <= Lebih baik karena membuat 6 lebih mudah dilihat.


jadi, saya <ukuran dibandingkan dengan saya <= LAST_FILLED_ARRAY_SLOT
Chris Cudmore

2

Kembali ke perguruan tinggi, saya ingat sesuatu tentang dua operasi ini menjadi serupa dalam waktu komputasi pada CPU. Tentu saja, kita berbicara di tingkat perakitan.

Namun, jika Anda berbicara C # atau Java, saya benar-benar tidak berpikir satu akan menjadi penambah kecepatan dari yang lain, Beberapa nanodetik yang Anda peroleh kemungkinan besar tidak sebanding dengan kebingungan yang Anda perkenalkan.

Secara pribadi, saya akan menulis kode yang masuk akal dari sudut pandang implementasi bisnis, dan memastikannya mudah dibaca.


2

Ini jatuh langsung di bawah kategori "Membuat Kode yang Salah Terlihat Salah" .

Dalam bahasa pengindeksan berbasis nol, seperti Java atau C # orang terbiasa dengan variasi pada index < countkondisi. Dengan demikian, meningkatkan konvensi defacto ini akan membuat kesalahan satu per satu lebih jelas.

Mengenai kinerja: setiap kompiler bagus yang bernilai jejak kakinya harus di-render seperti non-isu.


2

Sebagai sedikit samping, ketika perulangan melalui array atau koleksi lainnya di. Net, saya menemukan

foreach (string item in myarray)
{
    System.Console.WriteLine(item);
}

agar lebih mudah dibaca daripada angka untuk loop. Ini tentu saja mengasumsikan bahwa penghitung Int yang sebenarnya itu sendiri tidak digunakan dalam kode loop. Saya tidak tahu apakah ada perubahan kinerja.


Ini juga mengharuskan Anda untuk tidak mengubah ukuran koleksi selama loop.
Jeff B

Begitu juga dengan (i = 0, i <myarray.count, i ++)
Rob Allen

1

Ada banyak alasan bagus untuk menulis i <7. Memiliki angka 7 dalam satu lingkaran yang berulang 7 kali adalah baik. Performanya identik secara efektif. Hampir semua orang menulis i <7. Jika Anda menulis agar mudah dibaca, gunakan formulir yang semua orang akan langsung kenal.


1

Saya selalu lebih suka:

for ( int count = 7 ; count > 0 ; -- count )

Apa alasanmu? Saya benar-benar tertarik.
Chris Cudmore

itu baik-baik saja untuk looping terbalik .. jika Anda membutuhkan hal seperti itu
ShoeLace

1
Salah satu alasannya adalah pada level UP dibandingkan dengan 0 adalah cepat. Yang lain adalah bahwa ia membacakan dengan baik untuk saya dan hitungan memberi saya indikasi mudah berapa kali lagi.
kenny

1

Membuat kebiasaan menggunakan <akan membuatnya konsisten untuk Anda dan pembaca ketika Anda mengulangi melalui array. Akan lebih mudah bagi semua orang untuk memiliki konvensi standar. Dan jika Anda menggunakan bahasa dengan array berbasis 0, maka <adalah konvensi.

Ini hampir pasti lebih penting daripada perbedaan kinerja apa pun antara <dan <=. Bertujuan untuk fungsionalitas dan keterbacaan pertama, lalu optimalkan.

Catatan lain adalah bahwa akan lebih baik dalam kebiasaan melakukan ++ i daripada i ++, karena mengambil dan menambah membutuhkan sementara dan peningkatan dan pengambilan tidak. Untuk bilangan bulat, kompiler Anda mungkin akan mengoptimalkan sementara pergi, tetapi jika jenis iterasi Anda lebih kompleks, itu mungkin tidak bisa.


1

Jangan gunakan angka ajaib.

Kenapa 7? (atau 6 dalam hal ini).

gunakan simbol yang benar untuk nomor yang ingin Anda gunakan ...

Dalam hal ini saya pikir lebih baik digunakan

for ( int i = 0; i < array.size(); i++ )

1

Operator '<' dan '<=' persis dengan biaya kinerja yang sama.

Operator '<' adalah standar dan lebih mudah dibaca dalam loop berbasis nol.

Menggunakan ++ i bukannya i ++ meningkatkan kinerja di C ++, tetapi tidak di C # - Saya tidak tahu tentang Java.


1

Seperti yang telah diamati orang, tidak ada perbedaan dalam salah satu dari dua alternatif yang Anda sebutkan. Hanya untuk mengonfirmasi ini, saya melakukan pembandingan sederhana dalam JavaScript.

Anda dapat melihat hasilnya di sini . Apa yang tidak jelas dari ini adalah bahwa jika saya menukar posisi tes 1 dan 2, hasil untuk 2 tes tersebut ditukar, ini jelas merupakan masalah memori. Namun tes ke-3, tes di mana saya membalikkan urutan iterasi jelas lebih cepat.


mengapa Anda mulai dengan i = 1 dalam kasus kedua?
Eugene Katz

Hrmm, mungkin kesalahan konyol? Saya menyiapkan ini dengan cukup cepat, mungkin 15 menit.
David Wees

1

Seperti yang dikatakan semua orang, sudah biasa menggunakan iterator yang diindeks 0 bahkan untuk hal-hal di luar array. Jika semuanya dimulai pada 0dan berakhir pada n-1, dan batas bawah selalu <=dan batas atas selalu <, ada jauh lebih sedikit pemikiran yang harus Anda lakukan ketika meninjau kode.


1

Pertanyaan yang bagus Jawaban saya: gunakan tipe A ('<')

  • Anda melihat dengan jelas berapa banyak iterasi yang Anda miliki (7).
  • Perbedaan antara dua titik akhir adalah lebar rentang
  • Lebih sedikit karakter membuatnya lebih mudah dibaca
  • Anda lebih sering memiliki jumlah total elemen i < strlen(s)daripada indeks elemen terakhir sehingga keseragaman itu penting.

Masalah lain adalah dengan keseluruhan konstruksi ini. imuncul 3 kali di dalamnya, sehingga dapat salah ketik. Konstruk for-loop mengatakan cara melakukan alih - alih apa yang harus dilakukan . Saya sarankan mengadopsi ini:

BOOST_FOREACH(i, IntegerInterval(0,7))

Ini lebih jelas, mengkompilasi untuk memberikan instruksi asm yang sama, dll. Tanyakan saya kode IntegerInterval jika Anda suka.


1

Begitu banyak jawaban ... tapi saya yakin saya punya sesuatu untuk ditambahkan.

Preferensi saya adalah angka-angka literal untuk dengan jelas menunjukkan nilai apa yang akan saya ambil dalam loop . Jadi dalam kasus iterasi melalui array berbasis nol:

for (int i = 0; i <= array.Length - 1; ++i)

Dan jika Anda hanya mengulang, tidak mengulangi melalui array, menghitung dari 1 hingga 7 cukup intuitif:

for (int i = 1; i <= 7; ++i)

Keterbacaan meningkatkan kinerja hingga Anda memprofilkannya, karena Anda mungkin tidak tahu apa yang akan dilakukan oleh kompiler atau runtime dengan kode Anda sampai saat itu.


1

Anda juga bisa menggunakannya !=. Dengan cara itu, Anda akan mendapatkan infinite loop jika Anda membuat kesalahan dalam inisialisasi, menyebabkan kesalahan diketahui sebelumnya dan masalah apa pun yang menyebabkannya dibatasi terjebak dalam loop (daripada memiliki masalah jauh kemudian dan tidak menemukan Itu).


0

Saya pikir baik-baik saja, tetapi ketika Anda telah memilih, tetap berpegang pada satu atau yang lain. Jika Anda terbiasa menggunakan <=, maka cobalah untuk tidak menggunakan <dan sebaliknya.

Saya lebih suka <=, tetapi dalam situasi di mana Anda bekerja dengan indeks yang dimulai dari nol, saya mungkin akan mencoba dan menggunakan <. Tapi itu semua preferensi pribadi.


0

Dari sudut pandang logis, Anda harus berpikir itu < countakan lebih efisien daripada <= countuntuk alasan yang tepat yang <=akan menguji kesetaraan juga.


Saya tidak berpikir begitu, dalam assembler itu bermuara ke cmp eax, 7 jl LOOP_START atau cmp eax, 6 jle LOOP_START keduanya membutuhkan jumlah siklus yang sama.
Treb

<= dapat diimplementasikan sebagai! (>)
JohnMcG

! (>) masih dua instruksi, tetapi Treb benar bahwa JLE dan JL keduanya menggunakan jumlah siklus clock yang sama, jadi <dan <= mengambil jumlah waktu yang sama.
Jacob Krall
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.