Porovnávacia tabuľka:
| Základ pre porovnanie | Call_By_Value | Call By Reference |
|---|---|---|
| základné | Kópia premennej je úspešná. | Samotná premenná je úspešná. |
| účinok | Zmena v kópii premennej nezmení pôvodnú hodnotu premennej na strane funkcie. | Zmena v premennej ovplyvňuje aj hodnotu premennej mimo funkcie. |
| Volanie parametrov | názov_funkcie (meno_zmeny1, meno_zmennej_2, ...; ...); | názov_funkcie (& variable_name1, & variable_name2, ...;); // v prípade objektu object.func_name (objekt); |
| Príjem parametrov | type function_name (typ variable_name1, type variable_name2, ... ...) {., } | zadajte typ_funkcie (typ * premenná_menu1, typ * premenná_zmenu2, ... ....) {., } // v prípade objektu zadajte názov_funkcie (typ_typu názov_objektu) {., } |
| Predvolené volanie | primitívny typ sa odovzdáva pomocou "volania podľa hodnoty". | objekty sú implicitne odovzdávané pomocou "volania podľa referencie". |
Definícia hodnoty po výzve
Ak zadáte prvotný typ údajov (celé číslo, znak a reťazec) na funkciu / metódu, prenesie sa na funkčný kód len "hodnota". Funkcia kopíruje hodnotu argumentu na "formálny parameter" funkčného kódu. Ak v funkčnom kóde dochádza k nejakej modifikácii formálneho parametra, nezmení sa pôvodná hodnota argumentu, ktorý sa používa na vyvolanie tejto funkcie.
Jednoducho povedané, ak sa funkcia / metóda nazýva prístupom "volanie podľa hodnoty"; potom sa kópia premennej odovzdá funkčnému kódu. Ak funkčný kód vykoná akékoľvek zmeny hodnoty v kópii premennej, nemení pôvodnú hodnotu premennej.
Pozrime sa na príklad, aby sme to stručne porozumeli.
// príklad v triede Java check {void change (int i, int j) {i = i * i; j = j / 2; system.out.println ("hodnota parametra vo funkcii"); system.out.println ("hodnota 'i', ktorá akceptuje hodnotu argumentu 'a'" + i); system.out.println ("hodnota 'j', ktorá akceptuje hodnotu argumentu 'b'" + j); }} trieda call_by _value {verejná statická void main (reťazec args []) {int a = 12, b = 20; skontrolujte C = nová kontrola (); system.out.println ("hodnota" a "a" b "pred volaním funkcie" + a + "" + b); C.change (a, b); // volanie podľa hodnoty. system.out.println ("hodnota" a "a" b "po volaní funkcie" + a + "" + b); }} // výstupná hodnota 'a' a 'b' pred volaním funkcie 12 20 hodnota parametra vo vnútri hodnoty funkcie 'i', ktorá akceptuje hodnotu argumentu 'a' 144 hodnota 'j', ktorá akceptuje hodnotu argument "b" 10 hodnota "a" a "b" po volaní funkcie 12 20 Definícia volania podľa odkazu
Referenčná metóda volania prostredníctvom odkazu prenesie referenciu / adresu argumentu do kódu funkcie. Keď sa adresa argumentu odovzdá funkčnému kódu, formálny parameter prijímania tejto adresy bude premenná ukazovateľa. Teraz, keď funkčný kód získal adresu argumentu, zmena hodnoty argumentu tiež zmení pôvodnú hodnotu argumentu.
V C ++ a Java je veľmi bežné, že objekt prechádza na funkciu / metódu a objekt je vždy odovzdaný jeho referenciou. Zmeny vykonané s objektom vo vnútri funkcie / metódy ovplyvňujú objekt, ktorý sa používa na vyvolanie tejto funkcie / metódy.
Nasledujúci fragment ukazuje správny spôsob "volania odkazom".
// príklad v swapovej triede C ++ {void swap (int * x, int * y) {int temp; teplota = * x; * X = * y; * Y = teplota; }} int hlavná {int a = 10, b = 20; cout << "hodnota a, b pred volaním funkcie" << << "" << Teraz poďme diskutovať o "výzve odkazom" tým, že odovzdáme "objekt" ako argument, ktorý implicitne vyhovuje prístupu "výzva odkazom".
kontrola triedy {int a, b; skontrolujte (int x, int b) {// objekt inicializovaný cez tento konštruktor a = x; b = y; } prázdna výmena (skontrolovať ob) {ob.a = a * 2; ob.b = b / 2; }} class main_class {public static void main (reťazec args []) {check C = nová kontrola (20, 40); // inicializácia objektu. system.out.println ("hodnota ob.a" a "ob.b" pred volaním funkcie "+ ob.a +" "+ ob.b); C.exchange (C); // volanie podľa odkazu. system.out.println ("hodnota ob.a" a "ob.b" pred volaním funkcie "+ ob.a +" "+ ob.b); }} // výstupná hodnota 'ob.a' a 'ob.b' pred volaním funkcie 20 40 hodnota 'ob.a' a 'ob.b' po volaní funkcie 40 20 Kľúčové rozdiely medzi hodnotami hovoru podľa hodnôt a odkazom na výzvu
- Odovzdanie argumentu pomocou prístupu "volanie podľa hodnoty" prechádza len kópiu tejto premennej, takže zmeny vykonané v kópii tejto premennej neovplyvnia pôvodnú hodnotu tejto premennej. V prístupe "volanie podľa referencie" sa samotná premenná odovzdáva ako argument, takže jej zmeny menia hodnotu pôvodnej premennej.
- Ak sú odovzdané argumenty primitívne dátové typy, sú to jednoducho "volanie podľa hodnoty", ale ak sú odovzdané referencie / adresy argumentov alebo objektov, potom sa funkcia nazýva metódou "call by reference".
- V prístupe "call by value" sú argumenty prenesené iba názvom premenných, zatiaľ čo v príkaze "call by reference" sú argumenty prenesené, názov premennej pozdĺž znaku '&' alebo objekt, ktorý je odovzdaný len jeho menom.
- Príjem parametrov argumentu v prístupe "volanie podľa hodnoty" je názov premennej spolu s jej typom údajov. V prístupe "volanie podľa referencie" je prijímací parameter vždy ukazovateľ ukazovateľ spolu s dátovým typom a v prípade objektu je to názov objektu spolu s jeho typom triedy.
záver:
C ++ a Java používajú oba prístupy v závislosti od toho, čo prešlo. Ak chcete odovzdať iba hodnotu premenlivej metódy používania "podľa hodnoty" a ak chcete vidieť zmenu pôvodnej hodnoty premennej, použite prístup "volanie podľa referencie".
