Un parametro di funzione in C ha sempre lo stesso indirizzo di memoria?

Question

Ok, quindi C è un valore pass-by, il che significa che una copia della variabile viene utilizzata al posto della variabile originale per il parametro, giusto? Quindi, quella copia avrà sempre lo stesso indirizzo di memoria? Considerate questo codice:

void test(int *ptr) { 
    printf("&ptr: %p\n", &ptr); 
    printf("ptr: %p\n", ptr); 
    printf("*ptr: %d\n\n", *ptr); 
} 

int main() { 
    int a = 1, b = 2, c = 3, d = 4, e = 5; 
    test(&a); 
    test(&b); 
    test(&c); 
    test(&d); 
    test(&e); 

    return 0; 
} 

L'uscita che ricevo da questo codice è questo:

&ptr: 0x7fff70536728 
ptr: 0x7fff7053674c 
*ptr: 1 

&ptr: 0x7fff70536728 
ptr: 0x7fff70536750 
*ptr: 2 

&ptr: 0x7fff70536728 
ptr: 0x7fff70536754 
*ptr: 3 

&ptr: 0x7fff70536728 
ptr: 0x7fff70536758 
*ptr: 4 

&ptr: 0x7fff70536728 
ptr: 0x7fff7053675c 
*ptr: 5 

La mia sensazione è stata "no". È a mia conoscenza che lo ptr non esiste al di fuori del blocco di codice di test(). Quindi, perché lo &ptr è lo stesso per tutte e cinque le chiamate di funzione?

Answer 1

&ptr è lo stesso perché ptr è una variabile locale all'interno di test(). Dato che chiami lo test() cinque volte di seguito senza che nulla intervenga, viene assegnato lo stesso indirizzo nello stack ogni volta che viene chiamato (nota, questo non è in alcun modo richiesto di C: è proprio come la tua macchina è facendolo, e come accadrebbe di solito).

Se chiamato una seconda funzione che poi si chiama test(), non si otterrebbe la stessa uscita per &ptr, dal momento che lo spazio nello stack in cui ptr stato precedentemente risiedeva viene oggi utilizzato dalla chiamata di funzione intervenire.

Per esempio:

#include <stdio.h> 

void test(int *ptr) { 
    printf("&ptr: %p\n", (void *) &ptr); 
    printf("ptr: %p\n", (void *) ptr); 
    printf("*ptr: %d\n\n", *ptr); 
} 

void test_test(void) { 
    int a = 1; 
    test(&a); 
} 

int main() { 
    int a = 1, b = 2, c = 3, d = 4, e = 5; 

    test(&a); 
    test(&b); 
    test(&c); 
    test(&d); 
    test(&e); 
    test_test(); 

    return 0; 
} 

rendimenti:

paul@local:~/src/c/scratch$ ./ptrtest 
&ptr: 0x7fff39f79068 
ptr: 0x7fff39f7909c 
*ptr: 1 

&ptr: 0x7fff39f79068 
ptr: 0x7fff39f79098 
*ptr: 2 

&ptr: 0x7fff39f79068 
ptr: 0x7fff39f79094 
*ptr: 3 

&ptr: 0x7fff39f79068 
ptr: 0x7fff39f79090 
*ptr: 4 

&ptr: 0x7fff39f79068 
ptr: 0x7fff39f7908c 
*ptr: 5 

&ptr: 0x7fff39f79048 
ptr: 0x7fff39f7906c 
*ptr: 1 

paul@local:~/src/c/scratch$ 

e si può vedere che &ptr è diverso l'ultima chiamata, che è fatto tramite test_test().