Összehasonlító táblázat:
| Az összehasonlítás alapja | Call_By_Value | Call By Reference |
|---|---|---|
| Alapvető | A változó egy példánya elhalad. | Egy változó is elhalad. |
| Hatás | A változó másolatának módosítása nem módosítja a változó oldal eredeti értékét. | A változó változása befolyásolja a függvényen kívül eső változó értékét is. |
| Hívásparaméterek | function_name (változó_név1, változó_neve2, ...); | function_name (& változó_neve1, és változó_neve2, ...); // objektum esetén object.func_name (objektum); |
| Paraméterek fogadása | írja be a function_name nevet (írja be a változó_név1 nevet, írja be a változó_neve2, ...) {. . } | írja be a function_name (* változó_név1 típusát, írja be a * változó_neve2, ...) {. . } // objektum esetén típusú függvénynév (class_type object_name) {. . } |
| Alapértelmezett hívás | a primitív típust a "hívás érték szerint" segítségével adjuk át. | az objektumok implicit módon kerülnek továbbításra a "hívás referencia" használatával. |
A hívás értékének meghatározása
Ha egy függvényhez / módszerhez egy primitív adattípust (egész szám, karakter és karakterlánc) ad át, akkor csak az „érték” kerül át a funkciókódra. A függvény egy argumentum értékét a függvénykód „formális paraméterére” másolja. Ha a függvénykódban bármilyen formai paraméter módosul, akkor nem módosítja az adott függvény hívásához használt argumentum eredeti értékét.
Egyszerű szavakkal, ha egy függvényt / módszert „hívás érték” megközelítéssel hívnak; majd a változó egy példányát továbbítja a funkciókódhoz. Ha egy funkciókód megváltoztatja a változó értékének értékét, akkor nem változtatja meg a változó eredeti értékét.
Lássunk egy példát, hogy ezt röviden megértsük.
// példa Java osztályellenőrzésben {void change (int i, int j) {i = i * i; j = j / 2; system.out.println ("a paraméteren belüli paraméter értéke"); system.out.println ("az" i "értéke, amely elfogadja az" a "" + i) argumentum értékét; system.out.println ("j" értéke, amely elfogadja az "b" "+ j" argumentum értékét); }} class call_by _value {public static void main (string args []) {int a = 12, b = 20; C = új ellenőrzés (); system.out.println (a "a" és "b" érték a "+ a +" "+ b) függvényhívás előtt; C.change (a, b); // érték szerinti hívás. system.out.println ("a" és "b" függvény a "+ a +" "+ b) függvényhívás után; }} // a 'a' és 'b' kimeneti értéke a függvény 12 20 értékének meghívása előtt az 'i' függvényértéken belül, amely elfogadja az '' '' érték '144' értékének az értékét. argumentum 'b' 10 'a' és 'b' érték a funkcióhívás után 12 20 A felhívás meghatározása
A Call by Reference módszer egy argumentum hivatkozását / címét adja át a funkciókódhoz. Mivel egy argumentum címe átadódik a funkciókódnak, a hivatalos paraméter, amely elfogadja ezt a címet, "pointer" változó lenne. Most, amikor a függvénykód megkapta az argumentum címét, az argumentum értékének módosítása módosítja az argumentum eredeti értékét is.
A C ++ és a Java-ban nagyon gyakori, hogy az objektumot átviszi a függvénynek / módszernek, és az objektum mindig a referenciáján van. A függvény / módszeren belül az objektumon végrehajtott változtatások befolyásolják a függvény / módszer felhívására használt objektumot.
A következő fragmens mutatja a helyes utat a „hívás referenciáknak” segítségével.
// példa C ++ osztály swap {void swap (int * x, int * y) {int temp; temp = * x; * X = * y; * Y = temp; }} int fő {int a = 10, b = 20; cout << "értéke a, b a" << a << "" < Most vitassuk meg a „hívás referenciát” úgy, hogy egy „objektumot” érvként adunk át, amelyet implicit módon a megközelítés „hívás referencia” útján ad át.
osztályellenőrzés {int a, b; check (int x, int b) {// objektum, amelyet az a = x; b = y; } érvénytelen csere (check ob) {ob.a = a * 2; ob.b = b / 2; }} class main_class {public static void main (string args []) {check C = új ellenőrzés (20, 40); // objektum inicializálása. system.out.println ("ob.a" és "ob.b" érték a "+ ob.a +" "+ ob.b) függvényhívás előtt; C.exchange (C); // hivatkozás szerinti hívás. system.out.println ("ob.a" és "ob.b" érték a "+ ob.a +" "+ ob.b) függvényhívás előtt; }} // 'ob.a' és 'ob.b' kimeneti értéke a függvényhívás 40 40 függvényhívás előtt 40 40 függvényhívás után A hívás szerinti érték és a hívás szerinti referencia közötti különbségek
- Az érvelés „hívás szerinti érték” megközelítéssel történő átadása csak a változó másolatát adja át, így az adott változó másolatában lévő érték módosításai nem befolyásolják a változó eredeti értékét. A „hívás referencia” megközelítésnél maga a változó argumentumként kerül átadásra, így a módosítások módosítják az eredeti változó értékét.
- Ha az átadott argumentumok primitív adattípusok, akkor egyszerűen „értéket hívnak”, de ha az argumentumok vagy objektumok referenciái / címei áthaladnak, akkor egy függvényt „hívás referencia” módszerrel hívnak.
- A „hívás érték szerint” megközelítésben az átadott érvek csak a változók nevét jelentik, míg a „hívás referencia” megközelítésben az átadott érvek, a változó neve a „&” jel mentén, vagy egy objektum, amelyet csak a neve alapján adnak át.
- Az argumentum paramétereinek fogadása a "hívás érték" megközelítésben változó neve az adattípussal együtt. A „hívás referencia” megközelítésnél a fogadó paraméter mindig az adat típusával együtt egy mutatóváltozó, és objektum esetén objektum neve és osztálytípusa.
Következtetés:
A C ++ és a Java mindkét megközelítést az elfogadottaktól függően használja. Ha csak a változó felhasználási érték értékét szeretné átadni, és ha azt szeretné látni, hogy a változó eredeti értéke változik, akkor használja a „hívás referencia” megközelítést.
