Carta Perbandingan:
| Asas untuk Perbandingan | Call_By_Value | Panggilan Rujukan |
|---|---|---|
| Asas | Satu salinan pembolehubah diluluskan. | Pembolehubah itu sendiri diluluskan. |
| Kesan | Perubahan dalam satu salinan pemboleh ubah tidak mengubah suai nilai asal pemboleh ubah di luar fungsi. | Perubahan dalam pembolehubah mempengaruhi nilai pembolehubah di luar fungsi juga. |
| Parameter Memanggil | function_name (variable_name1, variable_name2, ...); | function_name (& variable_name1, & variable_name2, ...); // dalam kes objek object.func_name (object); |
| Parameter Terima | taip function_name (taip variable_name1, taip variable_name2, ...). {. . } | taip function_name (taip * variable_name1, taip * variable_name2, ...). {. . } // dalam kes objek taip function_name (class_type object_name) {. . } |
| Panggilan lalai | jenis primitif diluluskan menggunakan "panggilan mengikut nilai". | objek secara tersirat diluluskan menggunakan "panggilan mengikut rujukan". |
Definisi Panggilan Mengikut Nilai
Jika anda melewati jenis data primitif (integer, watak, dan rentetan) ke fungsi / kaedah, maka hanya "nilai" yang diluluskan ke kod fungsi. Fungsi ini menyalin nilai hujah kepada 'parameter formal' kod fungsi. Sekiranya terdapat sebarang pengubahsuaian kepada parameter rasmi dalam kod fungsi, ia tidak akan mengubah nilai asal hujah yang digunakan untuk memanggil fungsi itu.
Secara ringkas, jika fungsi / kaedah dipanggil dengan pendekatan 'panggilan dengan nilai'; maka satu salinan pembolehubah diluluskan kepada kod fungsi. Sekiranya kod fungsi membuat apa-apa perubahan kepada nilai dalam salinan pembolehubah, ia tidak mengubah nilai asal pemboleh ubah itu.
Mari lihat contoh untuk memahami ini secara ringkas.
// contoh dalam kelas kelas Java {void change (int i, int j) {i = i * i; j = j / 2; system.out.println ("nilai parameter di dalam fungsi"); system.out.println ("nilai 'i' yang menerima nilai argumen 'a'" + i); system.out.println ("nilai 'j' yang menerima nilai argumen 'b'" + j); }} class call_by _value {public static void main (string args []) {int a = 12, b = 20; semak C = cek baru (); system.out.println ("nilai 'a' dan 'b' sebelum fungsi panggilan" + a + "" + b); C.change (a, b); // panggilan dengan nilai. system.out.println ("nilai 'a' dan 'b' selepas panggilan fungsi" + a + "" + b); }} // nilai output 'a' dan 'b' sebelum fungsi panggilan 12 20 nilai parameter di dalam nilai fungsi 'i' yang menerima nilai argumen 'a' 144 nilai 'j' yang menerima nilai hujah 'b' 10 nilai 'a' dan 'b' selepas panggilan fungsi 12 20 Definisi Call By Reference
Kaedah panggilan oleh Rujukan melepasi rujukan / alamat hujah kepada kod fungsi. Oleh kerana alamat hujah diteruskan ke kod fungsi, parameter formal yang menerima alamat itu akan menjadi pembolehubah 'penunjuk'. Sekarang, sebagai kod fungsi telah memperoleh alamat hujah, pengubahsuaian dalam nilai hujah juga akan mengubah nilai asal hujah.
Dalam C ++ dan Java, sangat umum untuk lulus objek ke fungsi / kaedah dan objek selalu diluluskan oleh rujukannya. Perubahan yang dilakukan ke objek di dalam fungsi / kaedah mempengaruhi objek yang digunakan untuk menggunakan fungsi / kaedah tersebut.
Mengikut pecahan menunjukkan cara yang betul untuk 'panggilan dengan rujukan'.
// contoh dalam swap kelas C + {void swap (int * x, int * y) {int temp; temp = * x; * x = * y; * Y = temp; }} int main {int a = 10, b = 20; cout << "nilai a, b sebelum fungsi panggilan" << a << "< Sekarang mari kita bincangkan 'panggilan dengan rujukan' dengan lulus 'objek' sebagai hujah, yang secara tersirat diluluskan oleh panggilan 'rujukan oleh rujukan'.
kelas cek {int a, b; periksa (int x, int b) {// objek diinisikan melalui pembangun ini a = x; b = y; } pertukaran tidak sah (periksa ob) {ob.a = a * 2; ob.b = b / 2; }} main_class kelas {public static void main (string args []) {cek C = new check (20, 40); // permulaan objek. system.out.println ("nilai 'ob.a' dan 'ob.b' sebelum fungsi panggilan" + ob.a + "" + ob.b); C. pertukaran (C); // panggilan dengan rujukan. system.out.println ("nilai 'ob.a' dan 'ob.b' sebelum fungsi panggilan" + ob.a + "" + ob.b); }} // nilai output 'ob.a' dan 'ob.b' sebelum fungsi panggilan 20 40 nilai 'ob.a' dan 'ob.b' selepas panggilan fungsi 40 20 Perbezaan Utama Antara Panggilan Mengikut Nilai dan Panggilan Rujukan
- Melewati hujah dengan menggunakan pendekatan 'panggilan berdasarkan nilai' hanya melepasi salinan pemboleh ubah tersebut, maka perubahan yang dibuat kepada nilai dalam salinan pembolehubah tersebut tidak mempengaruhi nilai asal pembolehubah tersebut. Dalam pendekatan 'panggilan dengan rujukan' pembolehubah itu sendiri diluluskan sebagai hujah, maka perubahan kepadanya mengubah nilai pemboleh ubah asal.
- Jika argumen yang diluluskan adalah datatip primitif mereka hanya 'panggilan dengan nilai', tetapi jika rujukan / alamat argumen atau objek diluluskan maka suatu fungsi dipanggil dengan 'panggilan dengan rujukan' kaedah.
- Dalam pendekatan 'call by value', argumen-argumen yang diluluskan adalah hanya nama pemboleh ubah manakala, dalam pendekatan 'panggilan dengan rujukan', argumen-argumen yang diluluskan adalah, nama berubah sepanjang tanda '&', atau objek yang diluluskan hanya dengan namanya.
- Menerima parameter hujah dalam pendekatan 'panggilan dengan nilai' adalah nama berubah bersama dengan jenis datanya. Dalam pendekatan 'panggilan dengan rujukan', parameter penerima sentiasa menjadi pembolehubah penunjuk bersama dengan jenis data dan dalam kes objek itu adalah nama objek bersama dengan jenis kelasnya.
Kesimpulan:
C ++ dan Java menggunakan kedua-dua pendekatan bergantung kepada apa yang diluluskan. Sekiranya anda hendak lulus hanya nilai penggunaan menggunakan nilai 'value by value' dan jika anda mahu melihat perubahan dalam nilai asal pemboleh ubah maka gunakan pendekatan 'panggilan dengan rujukan'.
