(C++) Subrutin: prosedur dan fungsi - 1

Subrutin

Menggunakan subrutin membolehkan anda mengelakkan pertindihan kod, jika anda perlu menulis kod yang sama di tempat yang berbeza dalam program. 
Pustaka yang diimport ke dalam program (contohnya, pustaka matematik сmath.h) 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 tugas,  sama ada hanya mengira sesuatu, atau mengeluarkan beberapa data, atau melakukan sesuatu yang lain. 

Subrutin terdiri daripada dua jenis - prosedur dan fungsi.

Subrutin melakukan beberapa tindakan, contohnya, memaparkan hasil pada skrin dalam bentuk tertentu (contoh mudah, operator printf()  ialah subrutin standard yang mencetak maklumat ke skrin)

Subrutin fungsi mengembalikan hasil (nombor, rentetan aksara, dll.) yang boleh kita gunakan dalam program utama.

Mari cuba tulis prosedur mudah:
Katakan kita mahu memaparkan rentetan "Ralat" setiap kali ralat boleh berlaku dalam kod disebabkan oleh kesalahan pengguna (contohnya, apabila dia memasukkan data yang salah)
Ini boleh dilakukan dengan menulis pernyataan cout << "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: #include<iostream> menggunakan ruang nama std; void printError() // penerangan prosedur { cout << "Ralat"; // badan prosedur - arahan bahawa prosedur akan dilaksanakan } utama() { ... printError() // mulakan prosedur untuk pelaksanaan. Kami hanya menentukan nama prosedur yang ingin kami laksanakan. ... printError() ... } Prosedur bermula dengan perkataan void. Terdapat kurungan kosong selepas nama prosedur.
Semua pernyataan yang dilaksanakan dalam prosedur diinden. 

Prosedur ditulis sebelum fungsi utama main()

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:   void printErrorZero() { cout << "Ralat. Bahagi dengan sifar!"; } void printErrorInput() { cout << "Ralat dalam input!"; } 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 void printError(rentetan) { cout << s; } 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 dengan koma dalam pengepala subprogram. Jenis parameter ditulis sebelum parameter.

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.

Pembolehubah tempatan dan global

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.
 
Program utama dalam C++ juga merupakan subrutin, jadi semua pembolehubah yang diisytiharkan di dalam main() ialah pembolehubah tempatan.
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 diubah 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: dipaparkan pada skrin

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
ujian batal() {   int i = 5; cout << i; }	ujian batal() {   int i = 5;   cout << i; } utama() { int i = 7;   cout << i;   ujian(); }	#include <iostream> menggunakan ruang nama std; int i; ujian batal() {   i = 2; } utama() { ujian(); cout << 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: void Swap ( int a, int b ) // dengan penerangan sedemikian tentang parameter prosedur, { // nilai-nilai argumen (x dan y) akan disalin, int c; // pembolehubah a dan b ialah pembolehubah bebas yang tidak berkaitan dengan x dan y c = a; a = b; b=c; } utama() { int x=1, y=2; Tukar(x, y); // nilai pembolehubah x dan y (argumen) disalin ke dalam parameter a dan b cout << "x=" << x<< ", y=" << y; // 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 melalui data melalui rujukan. Untuk melakukan ini, selepas nama jenis data dalam pengepala subrutin, anda mesti meletakkan tanda & ("ampersand"). void Swap ( int & a, int & b ) // kini pembolehubah a dan b mendapat alamat pembolehubah x dan y dalam ingatan { int c; c = a; a = b; b=c; } 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); Training problem Mengubah Hujah