Aanbevolen, 2024

Editor'S Choice

Verschil tussen oproep op waarde en Oproep op referentie

In C ++ en Java zijn er twee manieren om een ​​functie of een methode aan te roepen. De eerste is "call by value" en de tweede is "call by reference". Oproep met waardenmethode geeft alleen de waarde van een variabele door aan de functiecode en als er een verandering is in de waarde van een variabele binnen die functie, heeft dit geen invloed op de oorspronkelijke waarde van die variabele. In call-by-verwijzingsmethode geven we de variabele zelf door in een argument, en de verandering in de waarde van een variabele beïnvloedt ook de oorspronkelijke waarde van die variabele. Het belangrijkste verschil tussen beide methoden is dat call-by-value de waarde van een variabele doorgeeft en dat call-by-reference het adres van die variabele doorgeeft.

Vergelijkingstabel:

Basis voor vergelijkingCall_By_ValueOproep door verwijzing
basis-
Een kopie van de variabele wordt doorgegeven.Een variabele zelf wordt gepasseerd.
EffectWijziging in een kopie van de variabele verandert de oorspronkelijke waarde van de variabele buiten de functie niet.Verandering in de variabele beïnvloedt ook de waarde van de variabele buiten de functie.
Parameters aanroepenfunction_name (variable_name1, variable_name2, ....);function_name (& variable_name1, & variable_name2, ....);
// in geval van object
object.func_name (object);
Parameters ontvangentype function_name (type variable_name1, type variable_name2, ...).)
{. . }
type function_name (type * variable_name1, type * variable_name2, ....) {. . }
// in geval van object
type function_name (class_type object_name)
{. . }
Standaard bellenprimitieve type worden doorgegeven met behulp van "call by value".objecten worden impliciet doorgegeven via "call by reference".

Definitie van Call By Value

Als u een primitief gegevenstype (geheel getal, teken en tekenreeks) doorgeeft aan een functie / methode, wordt alleen de "waarde" doorgegeven aan de functiecode. De functie kopieert die waarde van een argument naar een 'formele parameter' van de functiecode. Als de formele parameter in een functiecode wordt gewijzigd, wijzigt deze niet de oorspronkelijke waarde van het argument dat wordt gebruikt om die functie aan te roepen.

In eenvoudige woorden, als een functie / methode wordt aangeroepen door 'call by value'-benadering; dan wordt een kopie van de variabele doorgegeven aan de functiecode. Als een functiecode wijzigingen aanbrengt in de waarde in de kopie van de variabele, verandert dit niet de oorspronkelijke waarde van de variabele.

Laten we een voorbeeld zien om dit kort te begrijpen.

 // voorbeeld in Java-klassecontrole {ongeldige wijziging (int i, int j) {i = i * i; j = j / 2; system.out.println ("waarde van parameter binnen de functie"); system.out.println ("waarde van 'i' die de waarde van argument 'a'" + i) accepteert; system.out.println ("waarde van 'j' die de waarde van argument 'b'" + j) accepteert; }} class call_by _value {public static void main (string args []) {int a = 12, b = 20; controleer C = nieuwe controle (); system.out.println ("waarde van 'a' en 'b' voor functieaanroep '+ a +' '+ b); C.change (a, b); // call by value. system.out.println ("waarde van 'a' en 'b' na functieaanroep" + a + "" + b); }} // uitvoerwaarde van 'a' en 'b' voor functieaanroep 12 20 waarde van parameter binnen de functiewaarde van 'i' die de waarde accepteert van argument 'a' 144 waarde van 'j' die de waarde accepteert van argument 'b' 10 waarde van 'a' en 'b' na functieaanroep 12 20 

Definitie van Call By Reference

Call by Reference-methode geeft een referentie / adres van een argument door aan de functiecode. Als het adres van een argument wordt doorgegeven aan de functiecode, is de formele parameter die dat adres accepteert een 'pointer'-variabele. Nu, aangezien de functiecode het adres van een argument heeft verkregen, zal de wijziging in de waarde van een argument ook de oorspronkelijke waarde van een argument wijzigen.

In C ++ en Java is het heel gebruikelijk om het object door te geven aan de functie / methode en het object wordt altijd doorgegeven door de referentie. Wijzigingen aan het object binnen de functie / methode beïnvloeden het object dat wordt gebruikt om die functie / methode aan te roepen.

Het volgende fragment toont de juiste manier om 'te bellen op basis van referentie'.

 // voorbeeld in C ++ class swap {void swap (int * x, int * y) {int temp; temp = * x; * = X * y; * Y = temp; }} int main {int a = 10, b = 20; cout << "waarde van a, b voor de functieaanroep" << a << "" < 

Laten we nu 'call by reference' bespreken door een 'object' als een argument door te geven, dat impliciet wordt overgenomen door de aanpak 'call by reference'.

 class check {int a, b; check (int x, int b) {// object geïnitialiseerd via deze constrtuctor a = x; b = y; } ongeldige uitwisseling (check ob) {ob.a = a * 2; ob.b = b / 2; }} class main_class {public static void main (string args []) {check C = nieuwe controle (20, 40); // objectinitialisatie. system.out.println ("waarde van 'ob.a' en 'ob.b' vóór functieaanroep" + ob.a + "" + ob.b); C.exchange (C); // bel door referentie. system.out.println ("waarde van 'ob.a' en 'ob.b' vóór functieaanroep" + ob.a + "" + ob.b); }} // uitvoerwaarde van 'ob.a' en 'ob.b' vóór functieaanroep 20 40 waarde van 'ob.a' en 'ob.b' na functieaanroep 40 20 

Belangrijkste verschillen tussen call-by-waarde en call-by-referentie

  1. Het argument doorgeven met behulp van de methode 'call by value' geeft alleen de kopie van die variabele door, dus wijzigingen in de waarde in de kopie van die variabele hebben geen invloed op de oorspronkelijke waarde van die variabele. In 'call by reference'-benadering wordt de variabele zelf als een argument doorgegeven, dus wijzigingen erin veranderen de waarde van de oorspronkelijke variabele.
  2. Als de doorgegeven argumenten primitieve datatypes zijn, zijn ze gewoon 'call by value', maar als de referenties / adressen van de argumenten of objecten worden doorgegeven, wordt een functie opgeroepen door de methode 'call by reference'.
  3. In 'call by value approach' zijn de aangenomen argumenten alleen de naam van de variabelen, terwijl in de 'call by reference'-benadering de doorgegeven argumenten zijn: variabele naam op' & 'teken of een object dat net door de naam wordt doorgegeven.
  4. Het ontvangen van parameters van het argument in de 'call by value'-benadering is de variabele naam samen met het gegevenstype. In 'call by reference'-benadering is de ontvangende parameter altijd een pointervariabele samen met het gegevenstype en in het geval van een object is het een objectnaam samen met zijn klassentype.

Conclusie:

C ++ en Java gebruiken beide benaderingen afhankelijk van wat wordt doorgegeven. Als u alleen de waarde van de variabele use'call by value'-methode wilt doorgeven en als u de wijziging in de oorspronkelijke waarde van de variabele wilt zien, gebruikt u de methode 'call by reference'.

Top