Mari bayangkan situasi di mana kita perlu memaparkan perkataan yang sama pada skrin, mari sebut perkataan itu "HELLO" ;, 10 kali. Apa yang perlu kita lakukan?
Anda boleh mengambil dan menulis arahan 10 kali Console.WriteLine("HELLO");
Tetapi bagaimana jika anda tidak memerlukan 10 kali, tetapi 20, 30, 40 kali? Dan jika 200 kali? Dalam kes ini, penyalinan akan mengambil masa yang sangat lama. Dan jika perlu pengguna memilih berapa kali untuk memaparkan maklumat pada skrin?
Untuk mengatasi tugas ini, kita boleh menggunakan binaan khas yang dipanggil gelung.
Gelung ialah pembinaan algoritmik di mana urutan arahan tertentu diulang beberapa kali.
Dalam bahasa pengaturcaraan C#, terdapat dua jenis gelung: gelung berubah (untuk) dan gelung bersyarat (semasa dan buat...semasa em>)
Mari mulakan perkenalan kita dengan kitaran dari jenis pertama.
Gelung dengan pembolehubah atau dengan bilangan langkah yang diketahui (untuk).
Selalunya berlaku bahawa kita mengetahui bilangan ulangan sesuatu tindakan, atau kita boleh serif">mengira bilangan ulangan menggunakan data yang kita tahu. Sesetengah bahasa pengaturcaraan mempunyai perintah yang dalam bahasa Rusia berbunyi seperti ulang (bilangan kali) - iaitu, kita boleh menentukan bilangan pengulangan yang tepat.
Adalah menarik untuk melihat bagaimana kitaran ini berfungsi pada peringkat mesin:
1. Sel memori tertentu diperuntukkan dalam ingatan dan bilangan ulangan ditulis kepadanya.
2. Apabila atur cara melaksanakan badan gelung sekali, kandungan sel ini (kaunter) dikurangkan dengan satu.
3. Gelung berakhir apabila sel ini sifar.
Dalam bahasa pengaturcaraan C#, tiada binaan sedemikian, sebaliknya binaan for.
Bentuk umum pengendali gelung for adalah seperti berikut:
untuk (/*expression1*/; /*expression2*/; /*expression3 */)
{
/*satu pernyataan atau blok pernyataan - badan gelung*/;
}
Konstruk ini memerlukan kita untuk:
1. Memperuntukkan sel memori secara eksplisit yang akan menjadi pembilang dan tetapkan nilai awalnya.
2. Kami telah menulis syarat di mana badan gelung akan dilaksanakan.
3. Tentukan bagaimana nilai dalam sel ini akan berubah.
Dalam bahagian praktikal, kami akan cuba memaparkan perkataan "Hello" 10 kali, dan dalam tugasan selanjutnya kami akan menganalisis pembinaan ini dengan lebih terperinci.
|
gelung for
Gelung for ialah satu cara untuk melangkah melalui tindakan berulang. Mari kita lihat dengan lebih dekat cara ia berfungsi.
Biasanya, bahagian untuk gelung mengambil langkah berikut:
1. Menetapkan nilai awal.
2. Menjalankan ujian keadaan untuk meneruskan gelung.
3. Lakukan tindakan gelung.
4. Kemas kini nilai yang digunakan dalam ujian.
dan kemudian langkah 2-4 diulang sehingga syarat dipenuhi. Sebaik sahaja syarat menjadi palsu, gelung ditamatkan dan pernyataan yang mengikuti pernyataan gelung for dilaksanakan.
Bentuk am gelung
untuk (/* ungkapan 1*/; /* ungkapan 2*/; /* ungkapan 3*/ )
{
/* satu pernyataan atau blok pernyataan - badan gelung */;
}
Ungkapan 1 bertanggungjawab untuk menetapkan nilai awal pembolehubah gelung (pembilang), berakhir dengan koma bertitik.
Sebagai contoh :
i=0; // pembolehubah gelung i tetapkan nilai awal sama dengan sifar - i hendaklah diisytiharkan sebelum gelung int i=0; // pembolehubah i boleh diisytiharkan serta-merta dalam pengepala gelung, tetapi dalam kes ini, ia akan dipadamkan daripada ingatan selepas gelung berjalan; // tiada permulaan dan pengisytiharan pembolehubah kitaran sama sekali, dalam kes ini, ia boleh diisytiharkan sebelum kitaran
Ungkapan 2 - ini ialah syarat untuk meneruskan gelung untuk, ia diuji kebenarannya. Sebagai contoh,
i <= 10 // gelung akan berjalan selagi pembolehubah i kurang daripada atau sama dengan 10.
Syaratnya boleh apa sahaja.
Ungkapan 3 menukar nilai pemboleh ubah pembilang. Tanpa nilai ini, gelung akan dianggap tidak terhingga. Sebagai contoh,
i++; // setiap kali isi gelung selesai, i ditambah sebanyak 1.
|
Boleh terdapat berbilang operator dalam setiap bahagian tajuk, dipisahkan dengan koma.< /span>
Contoh tajuk:
untuk ( int i = 0; i < 10; i + + ) { ... } - tajuk standard
untuk ( int i = 0, x = 1; i < 10; i += 2, x *= 2 ){ ... }
// dalam kes ini, kami menggunakan dua pembolehubah yang akan berubah selepas pelaksanaan badan gelung - ini ialah pembolehubah i dan x
// perubahan i pembolehubah dalam kenaikan 2 - i+=2 - singkatan untuk i=i+2
// pembolehubah x meningkat sebanyak 0.1 kali dengan setiap langkah x=x*2 - disingkatkan х*=2< /span>
|
Ulang N kali
Semua program dengan gelung for yang telah kami tulis setakat ini tidak boleh dipanggil universal. Kerana kita menetapkan sendiri bilangan ulangan badan gelung. Tetapi bagaimana jika bilangan ulangan bergantung pada beberapa nilai lain? Sebagai contoh, pengguna sendiri ingin menetapkan bilangan ulangan kitaran.
Apa yang perlu dilakukan dalam kes ini? Semuanya sangat mudah. Daripada nilai mula dan tamat angka, kita boleh menggunakan sebarang pembolehubah yang boleh dikira atau ditetapkan oleh pengguna.
Sebagai contoh, kita perlu memaparkan petak nombor daripada 1 hingga N, di mana nilai pembolehubah N dimasukkan daripada papan kekunci oleh pengguna.
Program ini akan kelihatan seperti ini:
#include <iostream>
menggunakan ruang nama std;
utama()
{
int i,N; // i – pembolehubah gelung, N - nombor maksimum yang mana kita mengira kuasa dua
cin>> N;
untuk ( i = 1; i <= N; i ++) // gelung: untuk semua i dari 1 hingga N. Pembolehubah i akan mengambil nilai secara berurutan dari 1 hingga N
{
cout << "Nombor persegi "<<i<<" ialah" <<i*i<<"\n"; // Mengeluarkan kuasa dua nombor dalam format tertentu dan bergerak ke baris baharu
}
}
Apabila memasuki gelung, pernyataan i = 1 dilaksanakan, dan kemudian pembolehubah i ditambah satu dengan setiap langkah (i ++ ). Gelung dilaksanakan manakala syarat i <= N adalah benar. Dalam badan gelung, satu-satunya pernyataan output mencetak nombor itu sendiri dan segi empat samanya pada skrin mengikut format yang ditentukan.
Untuk kuasa dua atau eksponen rendah yang lain, lebih baik menggunakan pendaraban.
Jalankan atur cara dan lihat hasil kerjanya dengan nilai berbeza bagi pembolehubah N.
|