Subrutin ialah bahagian berasingan program yang mempunyai nama dan menyelesaikan tugasnya yang berasingan. Subrutin terletak pada permulaan program utama dan boleh dilancarkan (dipanggil) daripada program utama dengan menyatakan nama.
Menggunakan subrutin membolehkan anda mengelakkan pertindihan kod jika anda perlu menulis kod yang sama dalam program tempat yang berbeza .
Perpustakaan yang diimport ke dalam program (contohnya, Sistem) terdiri daripada rutin yang telah disusun oleh seseorang. Pengaturcara tidak perlu memikirkan algoritma apa yang dilaksanakan di dalamnya, mereka hanya menggunakannya, hanya memikirkan apa sebenarnya yang mereka lakukan. Ini adalah penjimat masa yang besar. Tidak perlu menulis algoritma yang telah ditulis oleh orang lain.
Setiap subrutin hanya perlu melakukan satu tugas, sama ada mengira sesuatu atau mengeluarkan beberapa data atau melakukan sesuatu yang lain.
Subrutin, atau kaedah, terdiri daripada dua jenis - fungsi (yang mengembalikan hasil kerja) dan prosedur (yang tidak).
Mari kita mulakan dengan jenis kedua. Mari cuba tulis contoh mudah.
Katakan kita perlu memaparkan rentetan "Ralat" pada skrin setiap kali ralat boleh berlaku dalam kod disebabkan oleh kesalahan pengguna (contohnya, apabila dia memasukkan data yang salah).
Ini boleh dilakukan dengan menulis pernyataan
Console.WriteLine("Error");
Sekarang mari bayangkan bahawa baris ini perlu disisipkan di banyak tempat dalam program. Sudah tentu, anda boleh menulisnya di mana-mana sahaja. Tetapi penyelesaian ini mempunyai dua kelemahan.
1) rentetan ini akan disimpan dalam ingatan berkali-kali;
2) jika kita ingin menukar output pada ralat, kita perlu menukar baris ini sepanjang program, yang agak menyusahkan.
Untuk kes sedemikian, kaedah dan prosedur diperlukan.
Program dengan prosedur mungkin kelihatan seperti ini:
menggunakan Sistem;
classProgram {
kekosongan statik PrintError() {
Console.WriteLine("Ralat");
lompang statik Utama() {
PrintError();
}
Prosedur bermula dengan perkataan batal. Selepas nama prosedur kurungan kosong ditulis.
Semua pernyataan yang dilaksanakan dalam prosedur diinden.
Pengubah suai Statik bermaksud bahawa medan, kaedah atau sifat yang diberikan tidak akan dimiliki oleh setiap objek kelas, tetapi untuk kesemuanya bersama-sama.
Kaedah dan prosedur ditulis sebelum kaedah utama Main().
Untuk merujuk kepada prosedur, dalam program utama anda perlu memanggilnya dengan nama dan jangan lupa menulis kurungan.
Anda boleh memanggil prosedur dalam program beberapa kali.
|
Sekarang mari bayangkan bahawa kita perlu memaparkan mesej yang berbeza sebagai tindak balas kepada ralat pengguna, bergantung pada sama ada betul-betul apa kesilapan yang dia buat.
Dalam kes ini, anda boleh menulis prosedur anda sendiri untuk setiap ralat:
void printErrorZero()
{
Console.WriteLine("Ralat. Pembahagian dengan sifar!");
}
void printErrorInput()
{
Console.WriteLine("Ralat dalam input!");
}
Bagaimana jika terdapat banyak lagi ralat yang mungkin berlaku? Maka penyelesaian ini tidak sesuai dengan kita.
Kita perlu belajar cara mengawal prosedur dengan memberitahu mesej ralat yang hendak dipaparkan.
Untuk melakukan ini, kami memerlukan parameter yang akan kami tulis dalam kurungan selepas nama prosedur
void printError(rentetan s)
{
Console.WriteLine(s);
}
Dalam prosedur ini, s ialah parameter - pembolehubah khas yang membenarkan kawalan prosedur.
Parameter ialah pembolehubah yang bergantung pada nilai operasi subrutin itu. Nama parameter disenaraikan dipisahkan dengan koma dalam pengepala subprogram. Jenis parameter ditulis sebelum parameter.
Sekarang, apabila memanggil prosedur, anda perlu menentukan nilai sebenar dalam kurungan yang akan diberikan kepada parameter ( pembolehubah s) dalam prosedur kami
printError("Ralat! Bahagi dengan sifar!");
Nilai ini dipanggil argumen.
Argumen ialah nilai parameter yang dihantar kepada subrutin apabila ia dipanggil.
Hujah boleh bukan sahaja nilai tetap, tetapi juga pembolehubah atau ungkapan aritmetik.< /span>< /span>
|
Pembolehubah tempatan dan global
Selalunya perlu menggunakan pembolehubah tambahan yang hanya akan digunakan dalam subrutin. Pembolehubah sedemikian dipanggil setempat (atau setempat) dan hanya boleh dimanipulasi dalam subrutin di mana ia dicipta.
Skop pembolehubah setempat ialah blok kurungan kerinting di mana ia diisytiharkan.
Program utama dalam C# juga merupakan subrutin, jadi semua pembolehubah yang diisytiharkan di dalam void Main() ialah pembolehubah setempat. Subrutin lain tidak "tahu" apa-apa tentang pembolehubah tempatan subrutin lain.
Oleh itu, adalah mungkin untuk mengehadkan skop (skop) pembolehubah hanya kepada subrutin di mana ia benar-benar diperlukan. Dalam pengaturcaraan, teknik ini dipanggil enkapsulasi - menyembunyikan pembolehubah daripada mengubahnya dari luar.
Jika perlu untuk mengisytiharkan pembolehubah yang boleh dilihat di mana-mana dalam atur cara (dalam mana-mana subrutin), maka pembolehubah tersebut diisytiharkan di luar semua subrutin (lihat program 3 daripada jadual di bawah).
Pembolehubah sedemikian dipanggil global.
Dalam C#, apabila program bermula, semua pembolehubah global ditetapkan secara automatik kepada sifar (pembolehubah boolean mengambil nilai palsu).
Analisis tiga program:
| 1) Dalam atur cara ini, pembolehubah i ialah setempat. Pembolehubah setempat diisytiharkan dalam subrutin. |
2) Di sini, walaupun terdapat pembolehubah i dalam atur cara utama (dengan nilai 7), pembolehubah tempatan baharu i dengan nilai 5 akan dicipta.
Apabila program ini dilaksanakan, nilai 75 akan muncul pada skrin. |
3) Program ini mempunyai pembolehubah global i. Nilainya boleh ditukar di dalam subrutin, dan di dalam program utama.
Prosedur ini akan berfungsi dengan pembolehubah global i dan ia akan diberikan nilai baharu bersamaan dengan 2. Nilai 2 dipaparkan. |
|
ujian kekosongan statik()
{
int i = 5;
Console.Write("i");
}
|
ujian kekosongan statik()
{
int i = 5;
Console.Write("i");
}
lompang statik Utama()
{
int i = 7;
Console.Write("i");
ujian();
}
|
menggunakan Sistem;
Program kelas
{
int i;
ujian kekosongan statik()
{
i = 2;
}
lompang statik Utama()
{
ujian();
Console.Write("i");
}
}
|
Tugas
Tulis prosedur yang menukar nilai dua pembolehubah.
Keistimewaan tugas ini ialah kita memerlukan perubahan yang dibuat dalam prosedur untuk diketahui oleh program panggilan.
Mari cuba tulis prosedur seperti ini:
Swap kekosongan statik (int a, int b) // dengan penerangan sedemikian tentang parameter prosedur,
{ // akan menyalin nilai argumen (x dan y)
int c; // pembolehubah a dan b ialah pembolehubah bebas yang tidak berkaitan dengan x dan y
c = a; a = b; b=c;
}
lompang statik Utama()
{
int x=1, y=2;
Tukar(x, y); //nilai pembolehubah x dan y (argumen) disalin ke dalam parameter a dan b, x = 1, y = 2
}
Jika anda menjalankan program ini, anda dapat melihat bahawa nilai pembolehubah x dan y tidak berubah. Untuk membolehkan parameter menukar nilai argumen, anda mesti menggunakan data yang melalui rujukan. Untuk melakukan ini, anda mesti menulis ref sebelum nama jenis data dalam pengepala daripada subrutin itu.
void Swap ( ref int a, ref int b ) // kini pembolehubah a dan b mendapat alamat pembolehubah x dan y dalam ingatan
{
int c;
c = a; a = b; b=c;
}
lompang statik Utama()
{
int x=1, y=2;
Tukar(rujuk x, rujukan y);
Aplikasi: jika anda meluluskan hujah melalui rujukan, maka hanya nama pembolehubah (BUKAN nombor dan BUKAN ungkapan aritmetik) boleh berdiri di tempat ini apabila memanggil prosedur.
Anda tidak boleh memanggil prosedur seperti ini:
Tukar(x, 4);
Tukar(5+x, y);
|
|