Сравнителна таблица:
| Основа за сравнение | Call_By_Value | Покана чрез справка |
|---|---|---|
| Основен | Предадено е копие на променливата. | Самата променлива се предава. |
| ефект | Промяната в копие на променливата не променя първоначалната стойност на променливата от страна на функцията. | Промяната в променливата също влияе върху стойността на променливата извън функцията. |
| Извикване на параметри | име_на_функция (име_на променлива1, променливо_намере2, ...); | име_на функция (& име_на променлива1, и променливо_намере2, ...); // в случай на обект object.func_name (object); |
| Получаващи параметри | напишете име_на_функция (напишете променлива_име1, въведете variable_name2, ...) {., } | напишете име_на_функция (тип * променлива_име1, въведете * променлива_име2, ...)., } // в случай на обект напишете име_на_функция (class_type име_на_обект) {., } |
| Стандартно повикване | примитивният тип се предава чрез "call by value". | обектите се подразбират имплицитно, като се използва "call by reference". |
Определение на стойността на повикването
Ако прехвърлите примитивен тип данни (цяло число, символ и низ) на функция / метод, то тогава към кода на функцията се предава само неговата стойност. Функцията копира тази стойност на аргумент в "официален параметър" на функционалния код. Ако има някаква модификация на формалния параметър в функционален код, тя няма да промени първоначалната стойност на аргумента, който се използва за извикване на тази функция.
С прости думи, ако функцията / методът се нарича с подход „кол по стойност“; след това копие на променливата се предава на функционалния код. Ако кодът на функцията прави промени в стойността в копието на променливата, той не променя първоначалната стойност на променливата.
Нека видим пример, за да разберем това накратко.
// пример в Java class check {void change (int i, int j) {i = i * i; j = j / 2; system.out.println ("стойност на параметъра вътре в функцията"); system.out.println ("стойност на" i ", която приема стойността на аргумент" a "" + i); system.out.println ("стойност на 'j', която приема стойността на аргумент 'b'" + j); }} клас call_by _value {публично статично празно главно (string args []) {int a = 12, b = 20; проверете C = нов чек (); system.out.println ("стойност на" a "и" b "преди извикване на функция" + a + "" + b); C.change (а, Ь); // извикване по стойност. system.out.println ("стойността на" a "и" b "след извикване на функция" + a + "" + b); }} // изходна стойност на 'a' и 'b' преди извикване на функция 12 20 на стойност на параметър във функционалната стойност на 'i', която приема стойността на аргумент 'a' 144 стойност на 'j', която приема стойността на аргумент 'b' 10 стойност на 'a' и 'b' след извикване на функция 12 20 Дефиниция на повикване по референция
Методът Call by Reference препраща референция / адрес на аргумент към функционалния код. Тъй като адресът на даден аргумент се предава на функционалния код, формалният параметър, приемащ този адрес, ще бъде променлива на 'указател'. Сега, когато функционалният код е получил адреса на аргумента, модификацията в стойността на аргумента също ще промени първоначалната стойност на аргумента.
В C ++ и Java, много често се предава обектът на функцията / метода, а обектът винаги се предава от неговия справочник. Промените, направени в обекта във функцията / метода, засягат обекта, използван за извикване на тази функция / метод.
Следващият фрагмент показва правилния начин за „повикване чрез препратка“.
// пример в C ++ клас swap {void swap (int * x, int * y) {int temp; температура = * х; * * Х = у; * Y = температура; }} int main {int a = 10, b = 20; cout << "стойност на a, b преди извикването на функцията" << a << "" < Сега нека обсъдим „повикване чрез препратка“, като предаваме „обект“ като аргумент, който имплицитно се предава от подхода „повикване чрез препратка“.
проверка на клас {int a, b; check (int x, int b) {// обект, инициализиран през този constrtuctor a = x; б = Y; } обмен на празноти (чек ob) {ob.a = a * 2; ob.b = b / 2; }} class main_class {публичен статичен void main (string args []) {проверка C = нова проверка (20, 40); // инициализация на обекта. system.out.println ("стойност на" ob.a "и" ob.b "преди извикване на функция" + ob.a + "" + ob.b); C.exchange (С); // извикване чрез препратка. system.out.println ("стойност на" ob.a "и" ob.b "преди извикване на функция" + ob.a + "" + ob.b); }} // изходна стойност на 'ob.a' и 'ob.b' преди извикване на функция 20 40 стойност на 'ob.a' и 'ob.b' след извикване на функция 40 20 Ключови разлики между стойността на повикването и референтния разговор
- Предаването на аргумента с помощта на подхода "call by value" предава само копието на тази променлива, така че промените, направени в стойността в копието на тази променлива, не засягат първоначалната стойност на тази променлива. В подхода "call by reference" променливата се предава като аргумент, така че се променя, като променя стойността на оригиналната променлива.
- Ако приетите аргументи са примитивни типове данни, те са просто „извикване по стойност“, но ако препратките / адресите на аргументите или обектите се предават, функцията се извиква чрез метод „call by reference“.
- При подхода „call by value“ аргументите са само името на променливите, докато в „call by reference“ се подхождат аргументите, които са пропуснати, името на променливата „&“ знак или обект, който се предава само от името му.
- Приемането на параметрите на аргумента в подхода "call by value" е име на променлива заедно с типа данни. В подхода "call by reference" приемният параметър винаги е променлива на показалеца, заедно с типа данни, а в случая на обекта е име на обект заедно с неговия тип клас.
Заключение:
C ++ и Java използват двата подхода в зависимост от това, което се предава. Ако искате да преминете само стойността на променливата use'call by value 'подход и ако искате да видите промяната в първоначалната стойност на променливата след това използвайте' call by reference 'подход.
