Perché l’esempio call-by-value non modifica i parametri di input?

Nel seguente esempio call-by-value, non riesco a capire perché questo codice non stia cambiando il valore del 5 in un 6.

La riga 11 chiama la funzione changeValue che ha il valore 6, quindi avrei pensato che fosse necessario emettere 6, tuttavia 5 è ancora in uscita?

#include  using namespace std; void changeValue(int value); int main() { int value = 5; changeValue(value); cout << "The value is : " << value << "." << endl; return 0; } void changeValue(int value) { value = 6; } // This doesn't change the value from 5 to 6. 5 is output? 

Quando si passa un argomento di funzione in base al valore, una copia dell’object viene passata alla funzione e non all’object originale. Se non si specifica esplicitamente, gli argomenti alle funzioni vengono sempre passati per valore in C / C ++.

La tua funzione:

 void changeValue(int value) 

riceve l’argomento per valore, in breve una copia del value in main() viene creata e passata alla funzione, la funzione opera su quel valore e non il value in main() .

Se si desidera modificare l’originale, è necessario utilizzare il pass per riferimento .

 void changeValue(int &value) 

Ora un riferimento (alias) al value originale viene passato alla funzione e la funzione opera su di esso, rispecchiando in tal modo le modifiche in main() .

Il valore del value non sta cambiando perché il tuo int che passi alla funzione viene copiato nello stack frame della funzione, quindi viene modificato e quando la funzione termina la copia viene distrutta. L’originale nel changeValue dello changeValue non è cambiato, poiché è stato copiato nel valore changeValue .

Se vuoi cambiarlo, dovresti passare un riferimento ad un int , come ad esempio void changeValue(int& value) , che dice che il valore non è copiato nella funzione, ma viene semplicemente passato un alias all’originale.

Il comportamento osservato al momento è perché passando per valore significa che una copia di valore (nuovo intero con valore di valore) viene effettivamente passata alla funzione.

Devi passare per riferimento. Per questo la funzione changeValue sarà simile a questa:

 void changeValue(int& value) 

Il resto del codice rimarrà lo stesso.

Passare una variabile per riferimento significa che lo stesso int value dichiarato in main viene passato alla funzione changeValue .

In alternativa, puoi passare un puntatore al value della funzione changeValue . Ciò tuttavia richiederà modifiche al modo in cui viene chiamata anche la funzione.

 int main() { int value = 5; changeValue(&value); ... return 0; } void changeValue(int* value) { *value = 6; } 

Sto includendo questa risposta come un altro modo di pensare alle funzioni di scrittura e al passaggio dei parametri in base al valore.

Potresti anche aver scritto questo codice nel modo seguente. Vale a dire passare il parametro in base al valore, modificare la copia locale nella funzione, che non modifica il valore originale e restituire il valore modificato.

 int changeValue(int val) { val = 6; return val; } int main() { int value = 5; value = changeValue(value); cout << "The value is : " << value << "." << endl; return 0; } 

Non sto in alcun modo indicando che il mio suggerimento per il tuo programma è migliore del passaggio per riferimento. Invece, è proprio il modo in cui l'apprendimento di un linguaggio di programmazione funzionale (Clojure) sta influenzando il modo in cui penso.

Inoltre, in lingue come Python, non è ansible modificare un parametro scalare. Puoi solo restituire un nuovo valore. Quindi la mia risposta è più un esercizio di riflessione sulle cose in modo diverso in C / C ++.

E:

la copia viene assegnata 6, ma la modifica non viene restituita.

hai bisogno di qualche riferimento o puntatore se vuoi cambiare il valore:

prova ad usare una firma del metodo come:

 void changeValue(int& value) 

probabilmente farà quello che ti aspettavi

Questo perché la modifica della funzione changeValue () è locale. Quando è ansible modificare changeValue (value) il contenuto del value della variabile in main viene copiato nell’argomento formale denominato value (lo stesso nome) della funzione. Lo stesso nome non significa che entrambi sono uguali. Il valore a cui accedi all’interno della funzione è una copia del valore che avevi nel main.

Per cambiare devi passare per riferimento o puntatore

 void changeValue (int *val) { *val = 6; } 

chiama con changeValue (&value) in main

Questo funziona perché viene passato l’indirizzo del value della variabile in main e questo valore di indirizzo viene copiato in val della funzione. Facendo *val possiamo ottenere il contenuto dell’indirizzo che è stato copiato in val , che in realtà è il contenuto del value in main.

O

 void changeValue (int &val) { val = 6; }