![Come Linux è stato sviluppato e sviluppato [Video]](https://gadget-info.com/img/how/761/how-linux-is-built-developed.jpg)
Grafico comparativo:
| Base per il confronto | Call_By_Value | Chiama per riferimento |
|---|---|---|
| Di base | Una copia della variabile è passata. | Viene passata una variabile. |
| Effetto | La modifica di una copia della variabile non modifica il valore originale della variabile al di fuori della funzione. | Il cambiamento nella variabile influenza anche il valore della variabile al di fuori della funzione. |
| Calling Parameters | nome_funzione (nome_variabile1, nome_variabile2, ...); | function_name (& variable_name1, & variable_name2, ...); // in caso di oggetto object.func_name (oggetto); |
| Ricezione di parametri | tipo nome_funzione (tipo nome_variabile1, tipo nome_variabile2, ...). {. . } | tipo nome_funzione (tipo * nome_variabile1, tipo * nome_variabile2, ....) {. . } // in caso di oggetto digita nome_funzione (class_type nome_oggetto) {. . } |
| Chiamata predefinita | il tipo primitivo viene passato usando "call by value". | gli oggetti vengono passati implicitamente usando "call by reference". |
Definizione di Call By Value
Se si passa un tipo di dati primitivo (intero, carattere e stringa) a una funzione / metodo, solo il suo "valore" viene passato al codice funzione. La funzione copia quel valore di un argomento in un "parametro formale" del codice funzione. Se c'è qualche modifica al parametro formale in un codice funzione, non modificherà il valore originale dell'argomento che è usato per chiamare quella funzione.
In parole semplici, se una funzione / metodo è chiamata dall'approccio 'call by value'; quindi una copia della variabile viene passata al codice funzione. Se un codice funzione apporta modifiche al valore nella copia della variabile, non modifica il valore originale della variabile.
Vediamo un esempio per capirlo brevemente.
// esempio nella classe di controllo di Java {void change (int i, int j) {i = i * i; j = j / 2; system.out.println ("valore del parametro all'interno della funzione"); system.out.println ("valore di 'i' che accetta il valore dell'argomento 'a'" + i); system.out.println ("valore di 'j' che accetta il valore dell'argomento 'b'" + j); }} class call_by _value {public static void main (string args []) {int a = 12, b = 20; controllare C = nuovo assegno (); system.out.println ("valore di 'a' e 'b' prima della chiamata di funzione" + a + "" + b); C.change (a, b); // chiama per valore. system.out.println ("valore di 'a' e 'b' dopo la chiamata di funzione" + a + "" + b); }} // valore di output di 'a' e 'b' prima della funzione chiamata 12 20 valore del parametro all'interno del valore della funzione di 'i' che accetta il valore dell'argomento 'a' 144 valore di 'j' che accetta il valore di argomento 'b' 10 valore di 'a' e 'b' dopo la chiamata di funzione 12 20 Definizione di chiamata per riferimento
Chiamata per metodo di riferimento passa un riferimento / indirizzo di un argomento al codice funzione. Poiché l'indirizzo di un argomento è passato al codice funzione, il parametro formale che accetta quell'indirizzo sarebbe una variabile 'puntatore'. Ora, poiché il codice funzione ha ottenuto l'indirizzo di un argomento, la modifica nel valore di un argomento modificherà anche il valore originale di un argomento.
In C ++ e Java, è molto comune passare l'oggetto alla funzione / metodo e l'oggetto viene sempre passato per riferimento. Le modifiche apportate all'oggetto all'interno della funzione / metodo influiscono sull'oggetto utilizzato per richiamare tale funzione / metodo.
Il seguente frammento mostra il modo corretto di "chiamare per riferimento".
// esempio in C ++ class swap {void swap (int * x, int * y) {int temp; temperatura = * x; * X = y *; * Y = temperatura; }} int main {int a = 10, b = 20; cout << "valore di a, b prima della funzione chiamata" << a << "" < Ora discutiamo di 'chiamata per riferimento' passando un 'oggetto' come argomento, che viene implicitamente passato dall'approccio 'chiamata per riferimento'.
controllo di classe {int a, b; check (int x, int b) {// oggetto inizializzato attraverso questo costrutto a = x; b = y; } void exchange (check ob) {ob.a = a * 2; ob.b = b / 2; }} classe main_class {public static void main (string args []) {check C = new check (20, 40); // inizializzazione dell'oggetto. system.out.println ("valore di 'ob.a' e 'ob.b' prima della chiamata di funzione" + ob.a + "" + ob.b); C.exchange (C); // chiama per riferimento. system.out.println ("valore di 'ob.a' e 'ob.b' prima della chiamata di funzione" + ob.a + "" + ob.b); }} // valore di uscita di 'ob.a' e 'ob.b' prima della chiamata di funzione 20 40 valore di 'ob.a' e 'ob.b' dopo la chiamata di funzione 40 20 Differenze chiave tra chiamata per valore e chiamata per riferimento
- Passando l'argomento usando l'approccio 'call by value' si passa solo la copia di quella variabile, quindi le modifiche apportate al valore nella copia di quella variabile non influenzano il valore originale di quella variabile. Nell'approccio 'call by reference' la variabile stessa viene passata come argomento, quindi le modifiche apportate modificano il valore della variabile originale.
- Se gli argomenti passati sono tipi di dati primitivi, sono semplicemente 'call by value', ma se i riferimenti / indirizzi degli argomenti o degli oggetti vengono passati, una funzione viene chiamata dal metodo 'call by reference'.
- In 'call by value approach' gli argomenti passati sono solo il nome delle variabili mentre, in 'call by reference', gli argomenti passati sono, nome della variabile lungo il segno '&', o un oggetto che viene passato solo dal suo nome.
- La ricezione dei parametri dell'argomento nell'approccio 'call by value' è il nome della variabile insieme al suo tipo di dati. Nell'approccio 'call by reference' il parametro ricevente è sempre una variabile puntatore insieme al tipo di dati e nel caso di oggetto è un nome oggetto insieme al suo tipo di classe.
Conclusione:
C ++ e Java usano entrambi gli approcci a seconda di ciò che viene passato. Se si desidera passare solo il valore dell'approccio della variabile use call 'value by value' e se si desidera vedere la modifica del valore originale della variabile, utilizzare quindi l'approccio 'call by reference'.
