Jämförelsediagram:
| Grunder för jämförelse | Call_By_Value | Ring via referens |
|---|---|---|
| Grundläggande | En kopia av variabeln passeras. | En variabel i sig är godkänd. |
| Effekt | Ändring av en kopia av variabel ändrar inte det ursprungliga värdet av variabel ut sidan av funktionen. | Ändring i variabeln påverkar också värdet av variabel utanför funktionen. |
| Samtalsparametrar | funktionsnamn (variabelnamn1, variabelnamn2, ...); | funktionsnamn (& variabelnamn1, & variabelnamn2, ...)); // vid objekt object.func_name (object); |
| Mottagande parametrar | skriv funktionsnamn (skriv variabel_namn1, skriv variabel_namn2, ....) {. . } | skriv funktionsnamn (typ * variable_name1, typ * variable_name2, ....) {. . } // vid objekt skriv funktionnamn (class_type object_name) {. . } |
| Standardanrop | primitiva typen skickas med "call by value". | Objekt är implicit godkända med hjälp av "call by reference". |
Definition av samtal efter värde
Om du skickar en primitiv datatyp (heltal, tecken och sträng) till en funktion / metod, skickas endast "värde" till funktionskoden. Funktionen kopierar det värdet av ett argument till en "formell parameter" av funktionskoden. Om det finns någon modifikation av den formella parametern i en funktionskod, ändras inte det ursprungliga värdet av argumentet som används för att ringa den funktionen.
I enkla ord, om en funktion / metod kallas för "call by value" då skickas en kopia av variabeln till funktionskoden. Om en funktionskod gör några ändringar i värdet i kopian av variabeln ändras inte det ursprungliga värdet av variabeln.
Låt oss se ett exempel för att förstå detta kortfattat.
// exempel i Java klasskontroll {void change (int i, int j) {i = i * i; j = j / 2; system.out.println ("värdet av parametern inuti funktionen"); system.out.println ("value of 'i' som accepterar värdet av argumentet 'a'" + i); system.out.println ("värde av" j "som accepterar värdet av argumentet" b "" + j); }} class call_by _value {public static void main (sträng args []) {int a = 12, b = 20; kolla C = ny kontroll (); system.out.println ("värde av" a "och" b "före funktionssamtal" + a + "" + b); C.change (a, b); // ring efter värde. system.out.println ("värdet av" a "och" b "efter funktionssamtal" + a + "" + b); }} // Utgångsvärde för 'a' och 'b' före funktionssamtal 12 20 Värdet av parametern inuti funktionsvärdet för 'I' som accepterar värdet av argumentet 'a' 144 värde av 'j' som accepterar värdet av argumentet "b" 10 värde av "a" och "b" efter funktionskall 12 20 Definition av samtal genom referens
Ring med referensmetod skickar en referens / adress till ett argument till funktionskoden. Eftersom adressen till ett argument skickas till funktionskoden, skulle den formella parametern som accepterar den adressen vara en "pekare" -variabel. Nu, som funktionskod har erhållit adressen till ett argument, ändrar modifikationen i värdet av ett argument också det ursprungliga värdet av ett argument.
I C ++ och Java är det mycket vanligt att skicka objektet till funktionen / metoden och objektet passeras alltid av dess referens. Ändringar gjorda till objektet inuti funktionen / metoden påverkar objektet som används för att åberopa den funktionen / metoden.
Följande fragment visar det rätta sättet att "ringa genom referens".
// exempel i C ++ klassbyte {void swap (int * x, int * y) {int temp; temp = * x; * X = * y; * Y = temp; }} int huvud {int a = 10, b = 20; cout << "värdet av a, b före funktionssamtalet" << a << "" < Låt oss nu diskutera "call by reference" genom att skicka ett "objekt" som ett argument, vilket implicit överensstämmer med metoden "call by reference".
klasskontroll {int a, b; kontrollera (int x, int b) {// objekt initierat genom denna constrtuctor a = x; b = y; } tomrumsutbyte (check ob) {ob.a = a * 2; ob.b = b / 2; }} klass main_class {public static void main (string args []) {kolla C = ny kontroll (20, 40); // objektinitiering. system.out.println ("värde av" ob.a "och" ob.b "före funktionssamtal" + ob.a + "" + ob.b); C.exchange (C); // Ring via referens. system.out.println ("värde av" ob.a "och" ob.b "före funktionssamtal" + ob.a + "" + ob.b); }} // utdatavärde för "ob.a" och "ob.b" före funktionssamtal 20 40 värde av "ob.a" och "ob.b" efter funktionssamtal 40 20 Viktiga skillnader mellan call by value och call via referens
- Passerar argumentet med hjälp av "Call by Value" -metoden passerar endast kopian av den variabeln, så ändringar som görs till värdet i kopian av den variabeln påverkar inte det ursprungliga värdet för den variabeln. I "Call by Reference" -metoden passeras variabeln själv som ett argument, så ändringar i det ändrar värdet på den ursprungliga variabeln.
- Om argumenten passerade är primitiva datatyper är de helt enkelt "call by value", men om referenser / adresser till argumenten eller objekten skickas, kallas en funktion genom "call by reference" -metoden.
- I "Call for Value Approach" är argumenten som passerat endast namnet på variabler, medan de argumenter som passerat är variabla namn längs '&' -tecknet, eller ett objekt som passeras av dess namn.
- Att mottaga parametrar för argumentet i "call by value" -metoden är variabelt namn tillsammans med dess datatyp. I "Call by Reference" -tilgangen är mottagarparametern alltid en pekervariabel tillsammans med datatypen och när det gäller objekt är det ett objektnamn tillsammans med sin klasstyp.
Slutsats:
C ++ och Java använder båda metoderna beroende på vad som passeras. Om du bara vill skicka värdet för variabel användning 'call by value' och om du vill se förändringen i variabelns ursprungliga värde, använd sedan "call by reference" -metoden.
