Cosa significa "dereferenziare" un puntatore?

Si prega di includere un esempio con la spiegazione.

Revisione della terminologia di base

Di solito è abbastanza buono - a meno che non si stia programmando un assembly - prevedere un puntatore contenente un indirizzo di memoria numerico, con 1 che si riferisce al secondo byte nella memoria del processo, 2 il terzo, 3 il quarto e così via ....

• Cosa è successo a 0 e al primo byte? Bene, ci arriveremo più avanti - vedi sotto i puntatori null .
• Per una definizione più accurata di cosa memorizzano i puntatori e di come si collegano memoria e indirizzi, vedere "Altre informazioni sugli indirizzi di memoria e perché probabilmente non è necessario saperlo" alla fine di questa risposta.

Quando si desidera accedere ai dati / valore nella memoria che i punti di puntatore - il contenuto del l'indirizzo con che indice numerico - allora si dereference il puntatore.

Diversi linguaggi per computer hanno notazioni diverse per dire al compilatore o all'interprete che ora sei interessato al valore (attuale) dell'oggetto puntato - Mi concentro di seguito su C e C ++.

Uno scenario puntatore

Considera in C, dato un puntatore come psotto ...

const char* p = "abc";

... quattro byte con i valori numerici usati per codificare le lettere 'a', 'b', 'c' e uno 0 byte per indicare la fine dei dati testuali, sono memorizzati da qualche parte nella memoria e l'indirizzo numerico di quello i dati sono archiviati in p. In questo modo C codifica il testo in memoria è noto come ASCIIZ .

Ad esempio, se la stringa letterale si trovasse all'indirizzo 0x1000 e pun puntatore a 32 bit a 0x2000, il contenuto della memoria sarebbe:

Memory Address (hex)    Variable name    Contents
1000                                     'a' == 97 (ASCII)
1001                                     'b' == 98
1002                                     'c' == 99
1003                                     0
...
2000-2003               p                1000 hex

Si noti che non v'è alcun nome / identificatore variabile per l'indirizzo 0x1000, ma possiamo indirettamente riferimento alla stringa letterale usando un puntatore memorizzare il suo indirizzo: p.

Dereferenziare il puntatore

Per fare riferimento ai caratteri pa cui puntiamo, facciamo una deduzione pusando una di queste notazioni (di nuovo, per C):

assert(*p == 'a');  // The first character at address p will be 'a'
assert(p[1] == 'b'); // p[1] actually dereferences a pointer created by adding
                     // p and 1 times the size of the things to which p points:
                     // In this case they're char which are 1 byte in C...
assert(*(p + 1) == 'b');  // Another notation for p[1]

Puoi anche spostare i puntatori attraverso i dati puntati, dereferenziandoli mentre procedi:

++p;  // Increment p so it's now 0x1001
assert(*p == 'b');  // p == 0x1001 which is where the 'b' is...

Se disponi di alcuni dati su cui puoi scrivere, puoi fare cose del genere:

int x = 2;
int* p_x = &x;  // Put the address of the x variable into the pointer p_x
*p_x = 4;       // Change the memory at the address in p_x to be 4
assert(x == 4); // Check x is now 4

Sopra, devi sapere al momento della compilazione che avresti bisogno di una variabile chiamata xe il codice chiede al compilatore di organizzare dove dovrebbe essere archiviato, assicurando che l'indirizzo sia disponibile via &x.

Dereferenziazione e accesso a un membro di dati della struttura

In C, se hai una variabile che è un puntatore a una struttura con membri di dati, puoi accedere a quei membri usando l' ->operatore di dereferencing:

typedef struct X { int i_; double d_; } X;
X x;
X* p = &x;
p->d_ = 3.14159;  // Dereference and access data member x.d_
(*p).d_ *= -1;    // Another equivalent notation for accessing x.d_

Tipi di dati multibyte

Per utilizzare un puntatore, un programma per computer ha anche bisogno di alcune informazioni sul tipo di dati a cui viene puntato: se quel tipo di dati richiede più di un byte per rappresentare, il puntatore normalmente punta al byte con il numero più basso nei dati.

Quindi, guardando un esempio leggermente più complesso:

double sizes[] = { 10.3, 13.4, 11.2, 19.4 };
double* p = sizes;
assert(p[0] == 10.3);  // Knows to look at all the bytes in the first double value
assert(p[1] == 13.4);  // Actually looks at bytes from address p + 1 * sizeof(double)
                       // (sizeof(double) is almost always eight bytes)
++p;                   // Advance p by sizeof(double)
assert(*p == 13.4);    // The double at memory beginning at address p has value 13.4
*(p + 2) = 29.8;       // Change sizes[3] from 19.4 to 29.8
                       // Note earlier ++p and + 2 here => sizes[3]

Puntatori alla memoria allocata dinamicamente

A volte non sai quanta memoria ti servirà fino a quando il tuo programma non sarà in esecuzione e vedrai quali dati vengono lanciati su di essa ... quindi puoi allocare dinamicamente la memoria usando malloc. È pratica comune memorizzare l'indirizzo in un puntatore ...

int* p = (int*)malloc(sizeof(int)); // Get some memory somewhere...
*p = 10;            // Dereference the pointer to the memory, then write a value in
fn(*p);             // Call a function, passing it the value at address p
(*p) += 3;          // Change the value, adding 3 to it
free(p);            // Release the memory back to the heap allocation library

In C ++, l'allocazione della memoria viene normalmente eseguita con l' newoperatore e la deallocazione con delete:

int* p = new int(10); // Memory for one int with initial value 10
delete p;

p = new int[10];      // Memory for ten ints with unspecified initial value
delete[] p;

p = new int[10]();    // Memory for ten ints that are value initialised (to 0)
delete[] p;

Vedi anche i puntatori intelligenti C ++ di seguito.

Perdere e perdere indirizzi

Spesso un puntatore può essere l'unica indicazione della posizione di alcuni dati o buffer nella memoria. Se è necessario un uso continuo di tali dati / buffer o la possibilità di chiamare free()o deleteevitare perdite di memoria, il programmatore deve operare su una copia del puntatore ...

const char* p = asprintf("name: %s", name);  // Common but non-Standard printf-on-heap

// Replace non-printable characters with underscores....
for (const char* q = p; *q; ++q)
    if (!isprint(*q))
        *q = '_';

printf("%s\n", p); // Only q was modified
free(p);

... o orchestrare attentamente l'inversione di qualsiasi modifica ...

const size_t n = ...;
p += n;
...
p -= n;  // Restore earlier value...
free(p);

Puntatori intelligenti C ++

In C ++, è consigliabile utilizzare oggetti puntatore intelligente per archiviare e gestire i puntatori, deallocandoli automaticamente quando vengono eseguiti i distruttori dei puntatori intelligenti. Da C ++ 11 la Libreria standard ne fornisce due, unique_ptrper quando esiste un unico proprietario per un oggetto allocato ...

{
    std::unique_ptr<T> p{new T(42, "meaning")};
    call_a_function(p);
    // The function above might throw, so delete here is unreliable, but...
} // p's destructor's guaranteed to run "here", calling delete

... e shared_ptrper la proprietà azionaria (utilizzando il conteggio dei riferimenti ) ...

{
    auto p = std::make_shared<T>(3.14, "pi");
    number_storage1.may_add(p); // Might copy p into its container
    number_storage2.may_add(p); // Might copy p into its container    } // p's destructor will only delete the T if neither may_add copied it

Puntatori null

In C NULLe 0- e in aggiunta in C ++ nullptr- possono essere usati per indicare che un puntatore non contiene attualmente l'indirizzo di memoria di una variabile e non dovrebbe essere dereferenziato o usato nell'aritmetica del puntatore. Per esempio:

const char* p_filename = NULL; // Or "= 0", or "= nullptr" in C++
int c;
while ((c = getopt(argc, argv, "f:")) != -1)
    switch (c) {
      case f: p_filename = optarg; break;
    }
if (p_filename)  // Only NULL converts to false
    ...   // Only get here if -f flag specified

In C e C ++, così come i tipi numerici incorporati non necessariamente predefinito a 0, nè boolsa false, i puntatori non sono sempre impostati NULL. Tutti questi sono impostati a 0 / false / NULL quando sono staticvariabili o (C ++ solo) variabili membro dirette o indirette di oggetti statici o le loro basi, o sottoposti a zero inizializzazione (ad esempio, new T();e new T(x, y, z);svolgono zero inizializzazione sui membri del T compresi i puntatori, mentre new T;non).

Inoltre, quando si assegnano 0, NULLe nullptrad un puntatore, i bit nel puntatore non sono necessariamente tutti ripristinati: il puntatore potrebbe non contenere "0" a livello hardware o fare riferimento all'indirizzo 0 nel proprio spazio di indirizzi virtuale. Il compilatore è permesso di negozio qualcos'altro lì, se ha motivo di, ma qualunque cosa faccia - se si arriva lungo e confrontare il puntatore 0, NULL, nullptro un altro puntatore che è stato assegnato una di queste, il lavoro di confronto must come previsto. Quindi, sotto il codice sorgente a livello di compilatore, "NULL" è potenzialmente un po '"magico" nei linguaggi C e C ++ ...

Ulteriori informazioni sugli indirizzi di memoria e sul perché probabilmente non è necessario saperlo

Più rigorosamente, i puntatori inizializzati memorizzano un modello di bit che identifica uno NULLo un indirizzo di memoria (spesso virtuale ).

Il semplice caso è dove questo è un offset numerico nell'intero spazio degli indirizzi virtuali del processo; in casi più complessi il puntatore può essere relativo ad un'area di memoria specifica, che la CPU può selezionare in base ai registri "segmenti" della CPU o in qualche modo di id di segmento codificato nel bit-pattern e / o guardare in luoghi diversi a seconda del istruzioni sul codice macchina utilizzando l'indirizzo.

Ad esempio, un int*inizializzato correttamente per puntare a una intvariabile potrebbe - dopo il cast in una float*- accedere alla memoria nella memoria "GPU" abbastanza distinta dalla memoria in cui si trova la intvariabile, quindi una volta lanciata e utilizzata come puntatore a funzione potrebbe puntare ulteriormente codici opzionali distinti di memoria della macchina per il programma (con il valore numerico di int*un puntatore casuale e non valido all'interno di queste altre aree di memoria).

I linguaggi di programmazione 3GL come C e C ++ tendono a nascondere questa complessità, in modo tale che:

• Se il compilatore ti dà un puntatore a una variabile o a una funzione, puoi dereferenziarla liberamente (purché la variabile non sia distrutta / deallocata nel frattempo) ed è il problema del compilatore se, ad esempio, è necessario ripristinare in anticipo un determinato registro di segmenti CPU o un istruzioni distinte di codice macchina utilizzate

• Se si ottiene un puntatore a un elemento in un array, è possibile utilizzare l'aritmetica del puntatore per spostarsi in qualsiasi altro punto dell'array o persino per formare un indirizzo oltre la fine dell'array che è legale per confrontare con altri puntatori a elementi nell'array (o che sono stati spostati in modo simile dall'aritmetica del puntatore sullo stesso valore uno-oltre-fine); sempre in C e C ++, spetta al compilatore assicurarsi che "funzioni"

• Funzioni specifiche del sistema operativo, ad esempio la mappatura della memoria condivisa, possono darti suggerimenti e "funzioneranno" all'interno della gamma di indirizzi che ha senso per loro

• I tentativi di spostare i puntatori legali oltre questi limiti, o di lanciare numeri arbitrari su puntatori o di utilizzare puntatori lanciati su tipi non correlati, in genere hanno un comportamento indefinito , quindi dovrebbero essere evitati in librerie e applicazioni di livello superiore, ma codice per sistemi operativi, driver di dispositivo, ecc. potrebbe essere necessario fare affidamento su comportamenti lasciati non definiti dallo standard C o C ++, che è comunque ben definito dalla loro specifica implementazione o hardware.

Dereferenziare un puntatore significa ottenere il valore archiviato nella posizione di memoria puntato dal puntatore. L'operatore * viene utilizzato per eseguire questa operazione e viene chiamato operatore di dereferenziazione.

int a = 10;
int* ptr = &a;

printf("%d", *ptr); // With *ptr I'm dereferencing the pointer. 
                    // Which means, I am asking the value pointed at by the pointer.
                    // ptr is pointing to the location in memory of the variable a.
                    // In a's location, we have 10. So, dereferencing gives this value.

// Since we have indirect control over a's location, we can modify its content using the pointer. This is an indirect way to access a.

 *ptr = 20;         // Now a's content is no longer 10, and has been modified to 20.

Un puntatore è un "riferimento" a un valore. Proprio come un numero di chiamata della biblioteca è un riferimento a un libro. "Dereferenziazione" il numero di chiamata sta fisicamente attraversando e recuperando quel libro.

int a=4 ;
int *pA = &a ;
printf( "The REFERENCE/call number for the variable `a` is %p\n", pA ) ;

// The * causes pA to DEREFERENCE...  `a` via "callnumber" `pA`.
printf( "%d\n", *pA ) ; // prints 4.. 

Se il libro non è lì, il bibliotecario inizia a gridare, chiude la biblioteca e un paio di persone sono disposte a indagare sulla causa di una persona che troverà un libro che non c'è.

In parole semplici, dereferenziare significa accedere al valore da una determinata posizione di memoria contro cui punta quel puntatore.

Codice e spiegazione dalle basi del puntatore :

L'operazione di dereference inizia dal puntatore e segue la sua freccia sopra per accedere alla sua punta. L'obiettivo potrebbe essere quello di guardare lo stato della punta o cambiare lo stato della punta. L'operazione di dereference su un puntatore funziona solo se il puntatore ha una punta: la punta deve essere allocata e il puntatore deve essere impostato per puntare su di esso. L'errore più comune nel codice del puntatore è dimenticare di impostare la punta. L'arresto anomalo del runtime più comune a causa di tale errore nel codice è un'operazione di dereference non riuscita. In Java la dereferenza errata verrà segnalata educatamente dal sistema di runtime. In linguaggi compilati come C, C ++ e Pascal, la dereferenza errata a volte si arresta in modo anomalo e altre volte corrompe la memoria in modo sottile e casuale.

void main() {   
    int*    x;  // Allocate the pointer x
    x = malloc(sizeof(int));    // Allocate an int pointee,
                            // and set x to point to it
    *x = 42;    // Dereference x to store 42 in its pointee   
}

Penso che tutte le risposte precedenti siano sbagliate, in quanto affermano che la dereferenziazione significa accedere al valore reale. Wikipedia fornisce invece la definizione corretta: https://en.wikipedia.org/wiki/Dereference_operator

Funziona su una variabile puntatore e restituisce un valore l equivalente al valore all'indirizzo del puntatore. Questo si chiama "dereferencing" il puntatore.

Detto questo, possiamo dereferenziare il puntatore senza mai accedere al valore a cui punta. Per esempio:

char *p = NULL;
*p;

Abbiamo referenziato il puntatore NULL senza accedere al suo valore. Oppure potremmo fare:

p1 = &(*p);
sz = sizeof(*p);

Ancora una volta, dereferenziando, ma non accedendo mai al valore. Tale codice NON si arresta in modo anomalo: l'arresto anomalo si verifica quando si accede effettivamente ai dati da un puntatore non valido. Tuttavia, sfortunatamente, secondo lo standard, la dereferenziazione di un puntatore non valido è un comportamento indefinito (con alcune eccezioni), anche se non si tenta di toccare i dati effettivi.

Quindi in breve: dereferenziare il puntatore significa applicare ad esso l'operatore dereference. Quell'operatore restituisce un valore l per il tuo uso futuro.