Sammenligningstabel:
| Grunnlag for sammenligning | Call_By_Value | Ring via referanse |
|---|---|---|
| grunn~~POS=TRUNC | En kopi av variabelen er bestått. | En variabel i seg selv er bestått. |
| Effekt | Endring i en kopi av variabel endrer ikke den opprinnelige verdien av variabel ut siden av funksjonen. | Endring i variabelen påvirker også verdien av variabelen utenfor funksjonen. |
| Ringe parametere | function_name (variable_name1, variable_name2, ...); | funksjonsnavn (& variable_name1, & variable_name2, ...)); // i tilfelle objekt object.func_name (objekt); |
| Motta parametere | skriv funksjonsnavn (skriv inn variabelnavn1, skriv variabelnavn2, ....) {. . } | skriv funksjonsnavn (type * variable_name1, type * variable_name2, ....) {. . } // i tilfelle objekt skriv funksjonsnavn (klasse_type objektnavn) {. . } |
| Standardoppringing | Primitive typen er bestått ved å bruke "Call for Value". | Objekter blir implisitt bestått ved å bruke "call by reference". |
Definisjon av ring etter verdi
Hvis du sender en primitiv datatype (heltall, tegn og streng) til en funksjon / metode, blir bare "verdi" overført til funksjonskoden. Funksjonen kopierer den verdien av et argument til en 'formell parameter' av funksjonskoden. Hvis det er noen modifikasjon av den formelle parameteren i en funksjonskode, vil den ikke endre den opprinnelige verdien av argumentet som brukes til å ringe den funksjonen.
I enkle ord, hvis en funksjon / metode kalles for "call for value" tilnærming; så sendes en kopi av variabelen til funksjonskoden. Hvis en funksjonskode gjør noen endringer i verdien i kopien av variabelen, endres ikke den opprinnelige verdien av variabelen.
La oss se et eksempel for å forstå dette kort.
// eksempel i Java klassekontroll {void change (int jeg, int j) {i = i * i; j = j / 2; system.out.println ("verdi av parameter inne i funksjonen"); system.out.println ("verdi av 'jeg' som aksepterer verdien av argumentet 'a'" + i); system.out.println ("verdi av 'j' som aksepterer verdien av argumentet 'b'" + j); }} class call_by _value {public static void main (string args []) {int a = 12, b = 20; sjekk C = ny sjekk (); system.out.println ("verdien av 'a' og 'b' før funksjonen anrop" + a + "" + b); C.change (a, b); // ring etter verdi. system.out.println ("verdi av 'a' og 'b' etter funksjonskall" + a + "" + b); }} // utgangsverdi for 'a' og 'b' før funksjonanrop 12 20 verdi av parameter inne i funksjonsverdien av 'i' som aksepterer verdien av argumentet 'a' 144 verdien av 'j' som aksepterer verdien av argument 'b' 10 verdi av 'a' og 'b' etter funksjonskall 12 20 Definisjon av samtale ved henvisning
Anrop via referansemetode sender en referanse / adresse til et argument til funksjonskoden. Når adressen til et argument sendes til funksjonskoden, vil den formelle parameteren som aksepterer adressen være en "peker" -variabel. Nå, som funksjonskode har fått adressen til et argument, vil endringen i verdien av et argument også endre den opprinnelige verdien av et argument.
I C ++ og Java er det veldig vanlig å sende objektet til funksjonen / metoden, og objektet blir alltid bestått av referansen. Endringer gjort til objektet inne i funksjonen / metoden påvirker objektet som brukes til å påkalle den funksjonen / metoden.
Følgende fragment viser den riktige måten å ringe ved referanse.
// eksempel i C ++ klasse bytte {tomt swap (int * x, int * y) {int temp; temp = * x; * X = * y; * Y = temp; }} int main {int a = 10, b = 20; cout << "verdien av a, b før funksjonssamtalen" << a << "" < La oss nå diskutere "call by reference" ved å sende et "objekt" som et argument, som er implisitt bestått av tilnærmingen "call by reference".
klassekontroll {int a, b; sjekk (int x, int b) {// objekt initialisert gjennom denne constrtuctor a = x; b = y; } tomtutveksling (sjekk ob) {ob.a = a * 2; ob.b = b / 2; }} klasse main_class {public static void main (streng args []) {sjekk C = ny sjekk (20, 40); // objektinitialisering. system.out.println ("verdi av 'ob.a' og 'ob.b' før funksjonskall" + ob.a + "" + ob.b); C.exchange (C); // ring ved referanse. system.out.println ("verdi av 'ob.a' og 'ob.b' før funksjonskall" + ob.a + "" + ob.b); }} // utgangsverdi for 'ob.a' og 'ob.b' før funksjonen samtale 20 40 verdi av 'ob.a' og 'ob.b' etter funksjonskall 40 20 Viktige forskjeller mellom samtale etter verdi og samtale ved henvisning
- Ved å sende argumentet ved å bruke 'call by value' tilnærming, passerer bare kopien av variabelen, slik at endringer som gjøres til verdien i kopien av den variabelen, påvirker ikke den opprinnelige verdien av den variabelen. I 'Call by Reference' tilnærming er variabelen selv bestått som et argument, slik at endringer i det endrer verdien av den opprinnelige variabelen.
- Hvis argumentene som er bestått, er primitive datatyper, er de ganske enkelt "call for value", men hvis referanser / adresser til argumenter eller objekter blir bestått, blir en funksjon kalt ved "call by reference" -metode.
- I "Call for Value Approach" er argumentene som er bestått, bare navnene på variabler, mens de i argumentene som er gått, er "variable ved navn", variabelt navn langs "&" -tegn, eller et objekt som er bestått bare etter navnet sitt.
- Mottak av parametere for argumentet i "call for value" tilnærming er variabelt navn sammen med datatypen. I mottaksparametre er mottaksparameteren alltid en pekervariabel sammen med datatypen, og i tilfelle av objekt er det et objektnavn sammen med sin klassetype.
Konklusjon:
C + + og Java bruker begge tilnærmingene, avhengig av hva som er bestått. Hvis du bare vil passere verdien av variabel use'call by value 'tilnærming, og hvis du vil se endringen i den opprinnelige verdien til variabelen, bruk deretter' call by reference 'tilnærming.
