Subrutin ialah bahagian berasingan program yang mempunyai nama dan menyelesaikan tugasnya yang berasingan. Subrutin terletak pada permulaan program utama dan boleh dilancarkan (dipanggil) dari program utama dengan menyatakan nama
Penggunaan subrutin membolehkan anda mengelakkan pertindihan kod, sekiranya anda perlu menulis kod yang sama di tempat yang berbeza dalam atur cara.
Perpustakaan yang diimport ke dalam program (contohnya, matematik perpustakaan matematik) terdiri daripada subrutin yang telah disusun oleh seseorang. Pengaturcara tidak perlu memikirkan algoritma apa yang mereka laksanakan, tetapi cukup gunakannya, hanya memikirkan apa sebenarnya yang mereka lakukan. Ini adalah penjimat masa yang besar. Tidak perlu menulis algoritma yang telah ditulis oleh orang lain.
Setiap rutin hanya perlu melakukan satu perkara: sama ada hanya mengira sesuatu, atau mengeluarkan beberapa data, atau melakukan sesuatu yang lain.
Terdapat dua jenis subrutin - prosedurdan fungsi
Subrutin melakukan beberapa tindakan, seperti mencetak hasil ke skrin dalam bentuk tertentu (contoh mudah, pernyataan writeln() ialah subrutin standard yang mencetak ke maklumat skrin)
Subrutin fungsi mengembalikan hasil (nombor, rentetan aksara, dll.) yang boleh kita gunakan dalam program utama.
Mari cuba tulis prosedur 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
writeln('Ralat');
Dan sekarang bayangkan bahawa baris sedemikian perlu dimasukkan 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, prosedur diperlukan.
Program dengan prosedur mungkin kelihatan seperti ini:
...
menggunakan ruang nama std;
prosedur printError(); // penerangan prosedur
bermula
writeln('Ralat'); // badan prosedur - arahan bahawa prosedur akan dilaksanakan
akhir;
// program utama
mulakan;
...
printerror(); // mulakan prosedur untuk pelaksanaan. Kami hanya menentukan nama prosedur yang ingin kami laksanakan.
...
printerror();
...
tamat.
Prosedur bermula dengan perkataan procedure. Selepas nama prosedur, kurungan ditulis, yang menunjukkan pembolehubah dan jenisnya yang bergantung kepada pelaksanaan prosedur. Contohnya:
var a, b, jawapan: integer;
prosedur Jumlah(a, b: integer);
mulakan
jawapan := a + b;
tamat;
Semua pernyataan yang dilaksanakan dalam prosedur diinden.
Prosedur ditulis sebelum program utama
Untuk melaksanakan prosedur, dalam program utama anda perlu memanggilnya dengan nama dan ingat untuk menulis kurungan!
Anda boleh memanggil prosedur dalam program beberapa kali.
|
Sekarang mari kita bayangkan bahawa kita perlu memaparkan mesej yang berbeza sebagai tindak balas kepada ralat pengguna, bergantung pada jenis kesilapan yang dia lakukan.
Dalam kes ini, anda boleh menulis prosedur anda sendiri untuk setiap ralat:
prosedur printErrorZero();
bermula
writeln('Ralat. Pembahagian dengan sifar!');
akhir;
prosedur printErrorInput();
bermula
writeln('Ralat dalam input!');
akhir;
Bagaimana jika terdapat banyak lagi kesilapan yang mungkin berlaku? Penyelesaian ini tidak sesuai dengan kami!
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
prosedur printError(s: string);
bermula
writeln(s);
tamat;
Dalam prosedur ini, s ialah parameter - pembolehubah khas yang membolehkan anda mengawal prosedur.
Parameter ialah pembolehubah yang menentukan cara subrutin berfungsi. Nama parameter disenaraikan dipisahkan oleh koma bertitik dalam pengepala subprogram. Selepas parameter, kolon diikuti dengan jenisnya.
Sekarang, apabila memanggil prosedur, anda perlu menunjukkan dalam kurungan nilai sebenar yang akan diberikan kepada parameter (pembolehubah s) di dalam prosedur kami
printError('Ralat! Pembahagian dengan sifar!');
Nilai ini dipanggil hujah.
Argumen ialah nilai parameter yang dihantar kepada subrutin apabila ia dipanggil.
Hujah boleh bukan sahaja nilai tetap, tetapi juga pembolehubah atau ungkapan aritmetik.
|
Selalunya perlu menggunakan pembolehubah tambahan yang hanya akan digunakan dalam subrutin. Pembolehubah sedemikian dipanggil lokal (atau setempat) dan hanya boleh dimanipulasi dalam subrutin di mana ia dicipta.
Skop pembolehubah setempat ialah fungsi atau prosedur di mana ia diisytiharkan
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 diubah dari luar.
Jika perlu untuk mengisytiharkan pembolehubah yang boleh dilihat di mana-mana dalam program (dalam mana-mana subrutin), maka pembolehubah tersebut diisytiharkan di luar semua subrutin (lihat program 3 daripada jadual di bawah)
Pembolehubah sedemikian dipanggil global.
Analisis tiga program:
| 1) Dalam atur cara ini, pembolehubah i ialah setempat. Pembolehubah tempatan 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 anda menjalankan program ini, skrin akan memaparkan nilai 75 |
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 pada skrin
ujian prosedur();
var i: integer;
mulakan
i := 5;
writeln(i);
tamat; |
var i: integer;
ujian prosedur();
var i: integer;
mulakan
i := 5;
writeln(i);
tamat;
mulakan
i := 7;
tulis(i);
ujian();
tamat. |
var i: integer;
ujian prosedur();
mulakan
i := 2;
tamat;
mulakan
ujian();
writeln(i);
tamat. |
Masalah: 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:
var x, y: integer;
prosedur Swap(a, b: integer); // dengan penerangan sedemikian tentang parameter prosedur,
var c: integer;
begin // akan menyalin nilai argumen (x dan y)
// pembolehubah a dan b ialah pembolehubah bebas yang tidak berkaitan dengan x dan y
c:= a;
a := b;
b:= c;
akhir;
bermula
x:= 1;
y:= 2;
Tukar(x, y); //nilai pembolehubah x dan y (argumen) disalin ke dalam parameter a dan b
writeln('x = ', x, ', y = ', y); // x=1, y=2
tamat.
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 melalui data melalui rujukan. Untuk melakukan ini, selepas nama jenis data dalam pengepala subrutin, anda mesti meletakkan perkataan var
prosedur Swap(var a, b: integer); // kini pembolehubah a dan b mendapat alamat pembolehubah x dan y dalam ingatan
var c: integer;
bermula
c:= a;
a := b;
b:= c;
akhir;
Penggunaan: Jika anda memberikan hujah melalui rujukan, maka hanya nama pembolehubah (BUKAN nombor dan BUKAN ungkapan aritmetik) boleh berada di tempat ini semasa memanggil prosedur!< br />
JANGAN panggil prosedur seperti ini:
Swap(x, 4);
Tukar(5+x, y);
|
|