it-swarm.com.de

Was bedeutet "Dereferenzieren" eines Zeigers?

Bitte fügen Sie der Erklärung ein Beispiel bei.

473
asir

Das Dereferenzieren eines Zeigers bedeutet, dass der Wert abgerufen wird, der an dem Speicherort gespeichert ist, auf den der Zeiger zeigt. Hierfür wird der Operator * verwendet, der als Dereferenzierungsoperator bezeichnet wird.

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.
87
Mahesh

Ein Zeiger ist eine "Referenz" auf einen Wert. Ähnlich wie eine Bibliotheksrufnummer eine Referenz auf ein Buch. Durch "Dereferenzieren" der Rufnummer wird das Buch physisch durchsucht und abgerufen.

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.. 

Wenn das Buch nicht da ist, fängt der Bibliothekar an zu schreien, schließt die Bibliothek und ein paar Leute werden nachforschen, warum jemand ein Buch findet, das nicht da ist.

16
bobobobo

In einfachen Worten bedeutet Dereferenzieren, dass auf den Wert von einer bestimmten Speicherstelle aus zugegriffen wird, auf die dieser Zeiger zeigt.

11
Fahad Naeem

Code und Erklärung von Pointer Basics :

Die Dereferenzierungsoperation beginnt am Zeiger und folgt seinem Pfeil, um auf seine Spitze zuzugreifen. Das Ziel kann sein, den Spitzenstatus zu betrachten oder den Spitzenstatus zu ändern. Die Dereferenzierungsoperation für einen Zeiger funktioniert nur, wenn der Zeiger eine Spitze hat - die Spitze muss zugewiesen und der Zeiger muss so eingestellt sein, dass er darauf zeigt. Der häufigste Fehler im Zeigercode besteht darin, das Einrichten des Pointees zu vergessen. Der häufigste Laufzeitabsturz aufgrund dieses Fehlers im Code ist eine fehlgeschlagene Dereferenzierungsoperation. In Java wird die fehlerhafte Dereferenzierung vom Laufzeitsystem höflich gekennzeichnet. In kompilierten Sprachen wie C, C++ und Pascal stürzt die inkorrekte Dereferenzierung manchmal ab und beschädigt den Speicher auf subtile, zufällige Weise. Zeigerfehler in kompilierten Sprachen können aus diesem Grund schwierig zu finden sein.

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   
}
7
atp

Ich denke, alle vorherigen Antworten sind falsch, da sie besagen, dass eine Dereferenzierung bedeutet, auf den tatsächlichen Wert zuzugreifen. Wikipedia gibt stattdessen die richtige Definition an: https://en.wikipedia.org/wiki/Dereference_operator

Sie verarbeitet eine Zeigervariable und gibt einen L-Wert zurück, der dem Wert an der Zeigeradresse entspricht. Dies wird als "Dereferenzieren" des Zeigers bezeichnet.

Das heißt, wir können den Zeiger dereferenzieren, ohne jemals auf den Wert zuzugreifen, auf den er zeigt. Zum Beispiel:

char *p = NULL;
*p;

Wir haben den NULL-Zeiger dereferenziert, ohne auf seinen Wert zuzugreifen. Oder wir könnten tun:

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

Erneut wird dereferenziert, aber es wird nie auf den Wert zugegriffen. Solcher Code stürzt NICHT ab: Der Absturz tritt auf, wenn Sie tatsächlich mit einem ungültigen Zeiger auf die Daten zugreifen . Leider ist die Dereferenzierung eines ungültigen Zeigers nach dem Standard ein undefiniertes Verhalten (mit wenigen Ausnahmen), auch wenn Sie nicht versuchen, die tatsächlichen Daten zu berühren.

Kurz gesagt: Beim Dereferenzieren des Zeigers wird der Dereferenzierungsoperator auf den Zeiger angewendet. Dieser Operator gibt nur einen L-Wert für Ihre zukünftige Verwendung zurück.

2
stsp