Passando per riferimento in C

Se C non supporta il passaggio di una variabile per riferimento, perché funziona?

#include <stdio.h>

void f(int *j) {
  (*j)++;
}

int main() {
  int i = 20;
  int *p = &i;
  f(p);
  printf("i = %d\n", i);

  return 0;
}

Produzione:

$ gcc -std=c99 test.c
$ a.exe
i = 21 

Perché stai passando il valore del puntatore al metodo e poi dereferenziandolo per ottenere il numero intero a cui è puntato.

Questo non è pass-by-reference, cioè pass-by-value come affermato da altri.

Il linguaggio C è pass-by-value senza eccezioni. Passare un puntatore come parametro non significa pass-by-reference.

La regola è la seguente:

Una funzione non è in grado di modificare il valore dei parametri effettivi.

Proviamo a vedere le differenze tra i parametri scalare e puntatore di una funzione.

Variabili scalari

Questo breve programma mostra il valore per passaggio usando una variabile scalare. paramviene chiamato parametro formale e variableall'invocazione della funzione viene chiamato parametro effettivo. L'incremento della nota paramnella funzione non cambia variable.

#include <stdio.h>

void function(int param) {
    printf("I've received value %d\n", param);
    param++;
}

int main(void) {
    int variable = 111;

    function(variable);
    printf("variable %d\m", variable);
    return 0;
}

Il risultato è

I've received value 111
variable=111

Illusione del pass-by-reference

Modifichiamo leggermente il codice. paramè un puntatore ora.

#include <stdio.h>

void function2(int *param) {
    printf("I've received value %d\n", *param);
    (*param)++;
}

int main(void) {
    int variable = 111;

    function2(&variable);
    printf("variable %d\n", variable);
    return 0;
}

Il risultato è

I've received value 111
variable=112

Questo ti fa credere che il parametro sia stato passato per riferimento. Non era. È stato passato per valore, il valore param è un indirizzo. Il valore del tipo int è stato incrementato e questo è l'effetto collaterale che ci fa pensare che fosse una chiamata di funzione pass-by-reference.

Puntatori - passati per valore

Come possiamo dimostrare / dimostrare questo fatto? Bene, forse possiamo provare il primo esempio di variabili scalari, ma invece di scalari usiamo gli indirizzi (puntatori). Vediamo se questo può aiutare.

#include <stdio.h>

void function2(int *param) {
    printf("param's address %d\n", param);
    param = NULL;
}

int main(void) {
    int variable = 111;
    int *ptr = &variable;

    function2(ptr);
    printf("ptr's address %d\n", ptr);
    return 0;
}

Il risultato sarà che i due indirizzi sono uguali (non preoccuparti del valore esatto).

Risultato di esempio:

param's address -1846583468
ptr's address -1846583468

A mio avviso, ciò dimostra chiaramente che i puntatori sono passati per valore. Altrimenti ptrsarebbe NULLdopo l'invocazione della funzione.

In C, il passaggio per riferimento viene simulato passando l'indirizzo di una variabile (un puntatore) e dereferenziando quell'indirizzo all'interno della funzione per leggere o scrivere la variabile effettiva. Questo sarà indicato come "pass-by-reference in stile C."

Fonte: www-cs-students.stanford.edu

Perché non esiste un riferimento pass-by nel codice sopra. L'uso di puntatori (come void func(int* p)) è pass-by-address. Questo è pass-by-reference in C ++ (non funzionerà in C):

void func(int& ref) {ref = 4;}

...
int a;
func(a);
// a is 4 now

Il tuo esempio funziona perché stai passando l'indirizzo della tua variabile a una funzione che manipola il suo valore con l' operatore di dereference .

Sebbene C non supporti i tipi di dati di riferimento , è comunque possibile simulare il passaggio per riferimento passando esplicitamente i valori del puntatore, come nell'esempio.

Il tipo di dati di riferimento C ++ è meno potente ma considerato più sicuro del tipo di puntatore ereditato da C. Questo sarebbe il tuo esempio, adattato per usare riferimenti C ++ :

void f(int &j) {
  j++;
}

int main() {
  int i = 20;
  f(i);
  printf("i = %d\n", i);

  return 0;
}

Stai passando un puntatore (indirizzo) in base al valore .

È come dire "ecco il posto con i dati che voglio che tu aggiorni".

p è una variabile puntatore. Il suo valore è l'indirizzo di i. Quando chiami f, passi il valore di p, che è l'indirizzo di i.

Nessun riferimento pass-by in C, ma p "si riferisce" a i e si passa p per valore.

In C tutto è pass-by-value. L'uso dei puntatori ci dà l'illusione che stiamo passando per riferimento perché il valore della variabile cambia. Tuttavia, se dovessi stampare l'indirizzo della variabile puntatore, vedrai che non viene influenzato. Una copia del valore dell'indirizzo viene passata alla funzione. Di seguito è riportato un frammento che illustra questo.

void add_number(int *a) {
    *a = *a + 2;
}

int main(int argc, char *argv[]) {
   int a = 2;

   printf("before pass by reference, a == %i\n", a);
   add_number(&a);
   printf("after  pass by reference, a == %i\n", a);

   printf("before pass by reference, a == %p\n", &a);
   add_number(&a);
   printf("after  pass by reference, a == %p\n", &a);

}

before pass by reference, a == 2
after  pass by reference, a == 4
before pass by reference, a == 0x7fff5cf417ec
after  pass by reference, a == 0x7fff5cf417ec

Perché stai passando un puntatore (indirizzo di memoria) alla variabile p nella funzione f. In altre parole, stai passando un puntatore, non un riferimento.

Risposta breve: Sì, C implementa il passaggio dei parametri per riferimento usando i puntatori.

Durante l'implementazione del passaggio dei parametri, i progettisti di linguaggi di programmazione usano tre diverse strategie (o modelli semantici): trasferire i dati nel sottoprogramma, ricevere i dati dal sottoprogramma o fare entrambi. Questi modelli sono comunemente noti come in modalità, modalità out e modalità out, di conseguenza.

Numerosi modelli sono stati ideati dai progettisti del linguaggio per implementare queste tre strategie elementari di passaggio dei parametri:

Passa per valore (semantica in modalità) Passa per risultato (semantica in modalità out) Passa per valore-risultato (semantica in modalità inout) Passa per riferimento (semantica in modalità inout) Passa per nome (modalità inout semantica)

Pass-by-reference è la seconda tecnica per il passaggio dei parametri inout-mode. Invece di copiare i dati avanti e indietro tra la routine principale e il sottoprogramma, il sistema di runtime invia un percorso di accesso diretto ai dati per il sottoprogramma. In questa strategia il sottoprogramma ha accesso diretto ai dati condividendo efficacemente i dati con la routine principale. Il vantaggio principale di questa tecnica è che è assolutamente efficiente nel tempo e nello spazio perché non è necessario duplicare lo spazio e non ci sono operazioni di copia dei dati.

Il parametro che passa l'implementazione in C: C implementa la semantica pass-by-value e pass-by-reference (inout mode) usando i puntatori come parametri. Il puntatore viene inviato al sottoprogramma e nessun dato reale viene copiato. Tuttavia, poiché un puntatore è un percorso di accesso ai dati della routine principale, il sottoprogramma può modificare i dati nella routine principale. C ha adottato questo metodo da ALGOL68.

I parametri che passano l'implementazione in C ++: C ++ implementano anche la semantica pass-by-reference (inout mode) usando i puntatori e usando anche un tipo speciale di puntatore, chiamato tipo di riferimento. I puntatori del tipo di riferimento sono implicitamente dereferenziati all'interno del sottoprogramma, ma anche la loro semantica è pass-by-reference.

Quindi il concetto chiave qui è che il riferimento pass-by implementa un percorso di accesso ai dati invece di copiarli nel sottoprogramma. I percorsi di accesso ai dati possono essere puntatori con riferimento esplicito o puntatori con riferimento automatico (tipo di riferimento).

Per maggiori informazioni, consultare il libro Concetti sui linguaggi di programmazione di Robert Sebesta, decima edizione, capitolo 9.

Non stai passando un int per riferimento, stai passando un puntatore a un int per valore. Sintassi diversa, stesso significato.

In C, per passare per riferimento usi l'operatore address-of &che dovrebbe essere usato contro una variabile, ma nel tuo caso, dato che hai usato la variabile pointer p, non hai bisogno di prefissarlo con l'operatore address-of. Sarebbe stato vero se si è utilizzato &icome parametro: f(&i).

Puoi anche aggiungere questo, a dereference pe vedere come quel valore corrisponde i:

printf("p=%d \n",*p);

puntatori e riferimenti sono due diversi thigngs.

Un paio di cose che non ho visto menzionate.

Un puntatore è l'indirizzo di qualcosa. Un puntatore può essere archiviato e copiato come qualsiasi altra variabile. Ha quindi una dimensione.

Un riferimento dovrebbe essere visto come un ALIAS di qualcosa. Non ha una dimensione e non può essere memorizzato. DEVE fare riferimento a qualcosa, ad es. non può essere nullo o modificato. Bene, a volte il compilatore deve memorizzare il riferimento come puntatore, ma questo è un dettaglio di implementazione.

Con i riferimenti non si hanno problemi con i puntatori, come la gestione della proprietà, il controllo nullo, la de-referenziazione durante l'uso.

'Passa per riferimento' (usando i puntatori) è stato in C dall'inizio. Perché pensi che non lo sia?

Penso che C in effetti supporti il ​​passaggio per riferimento.

Molte lingue richiedono che lo zucchero sintattico passi per riferimento anziché per valore. (Ad esempio C ++ richiede e nella dichiarazione dei parametri).

C richiede anche zucchero sintattico per questo. È * nella dichiarazione del tipo di parametro e & sull'argomento. Quindi * e & è la sintassi C per pass per riferimento.

Si potrebbe ora sostenere che il passaggio reale per riferimento dovrebbe richiedere solo la sintassi sulla dichiarazione del parametro, non sul lato argomento.

Ma ora arriva C #, che fa il supporto da accenno e richiede zucchero sintattico su entrambi i lati dei parametri e argomenti.

L'argomentazione secondo cui C non ha un passaggio di by-ref fa sì che gli elementi sintattici che lo esprimono mostrino l'implementazione tecnica sottostante non è affatto un argomento, poiché ciò si applica più o meno a tutte le implementazioni.

L'unico argomento rimasto è che passare per ref in C non è una caratteristica monolitica ma combina due caratteristiche esistenti. (Prendi ref dell'argomento con &, aspetta che ref digiti per *. C # per esempio richiede due elementi sintattici, ma non possono essere usati l'uno senza l'altro.

Questo è ovviamente un argomento pericoloso, poiché molte altre funzionalità nelle lingue sono composte da altre funzionalità. (come il supporto delle stringhe in C ++)

Quello che stai facendo è passare per valore non passare per riferimento. Perché stai inviando il valore di una variabile 'p' alla funzione 'f' (in principale come f (p);)

Lo stesso programma in C con pass per riferimento apparirà, (!!! questo programma fornisce 2 errori poiché pass per riferimento non è supportato in C)

#include <stdio.h>

void f(int &j) {    //j is reference variable to i same as int &j = i
  j++;
}

int main() {
  int i = 20;
  f(i);
  printf("i = %d\n", i);

  return 0;
}

Produzione:-

3:12: errore: previsto ';', ',' o ')' prima del token '&'
             void f (int & j);
                        ^
9: 3: avviso: dichiarazione implicita della funzione 'f'
               fa);
               ^