Tabela za primerjavo:
| Podlaga za primerjavo | Call_By_Value | Referenčni klic |
|---|---|---|
| Osnovno | Kopija spremenljivke je posredovana. | Spremenljiva je sama spremenljivka. |
| Učinek | Sprememba v kopiji spremenljivke ne spremeni prvotne vrednosti spremenljivke iz strani funkcije. | Sprememba spremenljivke vpliva tudi na vrednost spremenljivke izven funkcije. |
| Klicanje parametrov | ime-funkcije (ime_ spremenljivke1, ime_ spremenljivke2, ...); | ime-funkcije (& ime_ spremenljivke1, in spremenljivka_2, ...); // v primeru objekta object.func_name (objekt); |
| Sprejemni parametri | vnesite ime_funkcije (vpišite ime_ spremenljivke1, vnesite ime_ spremenljivke2, ...) {. . } | vpišite ime_funkcije (vnesite * spremenljivko_ime1, vnesite * spremenljivko_ime2, ...). . } // v primeru objekta vnesite ime_funkcije (tip_vrste ime_objekta) {. . } |
| Privzeto klicanje | primitivni tip se prenese z "call by value". | predmeti se implicitno prenesejo z uporabo "klic z referenco". |
Opredelitev klicne vrednosti
Če posredujete primitivni tip podatkov (celo število, znak in niz) funkciji / metodi, potem je koda funkcije prenesena samo njena vrednost. Funkcija kopira to vrednost argumenta v 'formalni parameter' kode funkcije. Če je kakšna sprememba formalnega parametra v funkcijski kodi, ne bo spremenila prvotne vrednosti argumenta, ki se uporablja za klic te funkcije.
S preprostimi besedami, če se funkcija / metoda imenuje s pristopom „klic po vrednosti“; potem se kopija spremenljivke prenese v funkcijsko kodo. Če koda funkcije spremeni vrednost v kopiji spremenljivke, ne spremeni prvotne vrednosti spremenljivke.
Oglejmo si primer, da na kratko to razumemo.
// primer v preverjanju razreda Java {void change (int i, int j) {i = i * i; j = j / 2; system.out.println ("vrednost parametra znotraj funkcije"); system.out.println ("vrednost" i ", ki sprejme vrednost argumenta" a "" + i); system.out.println ("vrednost 'j', ki sprejme vrednost argumenta 'b'" + j); }} razred call_by _value {javna statična void main (string args []) {int a = 12, b = 20; preverite C = nov ček (); system.out.println ("vrednost" a "in" b "pred klicem funkcije" + a + "" + b); C. sprememba (a, b); // klic po vrednosti. system.out.println ("vrednost" a "in" b "po pozivu funkcije" + a + "" + b); }} // izhodna vrednost 'a' in 'b' pred funkcijo klic 12 20 vrednost parametra znotraj vrednosti funkcije 'i', ki sprejema vrednost argumenta 'a' 144 vrednost 'j', ki sprejema vrednost \ t argument 'b' 10 vrednost 'a' in 'b' po klicu funkcije 12 20 Opredelitev klicnega sklicevanja
Call by reference metoda posreduje referenco / naslov argumenta funkcijski kodi. Ker je naslov argumenta posredovan funkcijski kodi, bi bil formalni parameter, ki sprejema ta naslov, spremenljivka "kazalec". Zdaj, ko je koda funkcije dobila naslov argumenta, bo sprememba vrednosti argumenta spremenila tudi izvirno vrednost argumenta.
V C + + in Javi je zelo običajno, da se objekt prenese na funkcijo / metodo in predmet se vedno prenese z njegovo referenco. Spremembe, izvedene v objektu znotraj funkcije / metode, vplivajo na objekt, ki se uporablja za klic te funkcije / metode.
Naslednji fragment kaže pravilen način za „klicanje z referenco“.
// primer v C ++ razredu swap {void swap (int * x, int * y) {int temp; temp = * x; * x = * y; * Y = temp; }} int main {int a = 10, b = 20; cout << "vrednost a, b pred klicem funkcije" << a << "" < Zdaj pa razpravljajmo o »klicu po referenci« tako, da posredujemo »predmet« kot argument, ki ga implicitno sprejmemo s pristopom »klic z referenco«.
preverjanje razreda {int a, b; check (int x, int b) {// objekt, ki je inicializiran skozi ta konstitutivni element a = x; b = y; } izmenjava (praznina ob) {ob.a = a * 2; ob.b = b / 2; }} class main_class {javni statični void main (string args []) {preverite C = nov ček (20, 40); // inicializacija objekta. system.out.println ("vrednost" ob.a "in" ob.b "pred klicem funkcije" + ob.a + "" + ob.b); C. Izmenjava (C); // klic z referenco. system.out.println ("vrednost" ob.a "in" ob.b "pred klicem funkcije" + ob.a + "" + ob.b); }} // izhodna vrednost 'ob.a' in 'ob.b' pred klicem funkcije 20 40 vrednost 'ob.a' in 'ob.b' po pozivu funkcije 40 20 Ključne razlike med vrednostjo klica in referenco
- Prenašanje argumenta z uporabo pristopa 'call by value' posreduje le kopijo te spremenljivke, tako da spremembe vrednosti v kopiji te spremenljivke ne vplivajo na izvirno vrednost te spremenljivke. V pristopu 'call by reference' je spremenljivka sama podana kot argument, zato se spremeni in spremeni vrednost izvirne spremenljivke.
- Če so podani argumenti primitivni tipi podatkov, so preprosto 'call by value', če pa so reference / naslovi argumentov ali objektov posredovani, se funkcija kliče po metodi 'call by reference'.
- V pristopu 'call by value' so posredovani argumenti samo ime spremenljivk, medtem ko se v 'call by reference' pristopajo argumenti, ki so bili posredovani, ime spremenljivke vzdolž znaka '&', ali predmet, ki se prenaša samo z njegovim imenom.
- Sprejemanje parametrov argumenta v pristopu 'call by value' je ime spremenljivke skupaj s podatkovnim tipom. Pri pristopu 'call by reference' je parameter sprejema vedno spremenljivka kazalca skupaj s tipom podatkov, v primeru objekta pa je ime objekta skupaj s tipom razreda.
Sklep:
C ++ in Java uporabljata oba pristopa, odvisno od tega, kaj je opravljeno. Če želite prenesti samo vrednost spremenljivke use'call by value 'pristop in če želite videti spremembo prvotne vrednosti spremenljivke, uporabite pristop' call by reference '.
