Bedeutung von “Referenzieren” und “Dereferenzieren” in C

Lesezeit: 10 Minuten

Benutzeravatar von Milkncookiez
Milkncookiez

Ich habe verschiedene Dinge im Internet gelesen und war verwirrt, weil jede Website etwas anderes sagt.

ich lese über * Referenzoperator und & Dereferenzierungsoperator; oder dass Referenzieren bedeutet, einen Zeiger auf eine Variable zeigen zu lassen, und Dereferenzieren bedeutet, auf den Wert der Variablen zuzugreifen, auf die der Zeiger zeigt. Also war ich verwirrt.

Kann ich eine einfache, aber gründliche Erklärung zum Thema “Referenzieren und Dereferenzieren” erhalten?

  • Beachten Sie, dass die offiziellen Namen Adresse (&) und Umleitung (*) Operator.

    – Daniel Fischer

    8. Januar 2013 um 22:19 Uhr

  • Du hast die Operatoren verwechselt. * ist der Dereferenzierungsoperator.

    – Cheznead

    6. April 2015 um 14:35 Uhr

  • Mögliches Duplikat von Was bedeutet “Dereferenzieren” eines Zeigers?

    – jww

    14. März 2018 um 21:36 Uhr

Benutzeravatar von AB
AB

Referenzieren bedeutet, die Adresse einer existierenden Variablen (mit &) zu nehmen, um eine Zeigervariable zu setzen. Um gültig zu sein, muss ein Zeiger auf die Adresse einer Variablen des gleichen Typs wie der Zeiger gesetzt werden, ohne das Sternchen:

int  c1;
int* p1;
c1 = 5;
p1 = &c1;
//p1 references c1

Dereferenzierung Ein Zeiger bedeutet die Verwendung des *-Operators (Sternchen), um den Wert von der Speicheradresse abzurufen, auf die der Zeiger zeigt: HINWEIS: Der an der Adresse des Zeigers gespeicherte Wert muss ein Wert VOM GLEICHEN TYP wie der Variablentyp sein der Zeiger “zeigt” auf, aber es gibt keine Garantie dies ist der Fall, es sei denn, der Zeiger wurde richtig gesetzt. Der Variablentyp, auf den der Zeiger zeigt, ist der Typ abzüglich des äußersten Sternchens.

int n1;
n1 = *p1;

Ungültige Dereferenzierung kann Abstürze verursachen oder auch nicht:

  • Das Dereferenzieren eines nicht initialisierten Zeigers kann zu einem Absturz führen
  • Die Dereferenzierung mit einer ungültigen Typumwandlung kann möglicherweise einen Absturz verursachen.
  • Das Dereferenzieren eines Zeigers auf eine Variable, die dynamisch zugewiesen und anschließend freigegeben wurde, kann zu einem Absturz führen
  • Das Dereferenzieren eines Zeigers auf eine Variable, die inzwischen den Gültigkeitsbereich verlassen hat, kann ebenfalls zu einem Absturz führen.

Ungültige Referenzierung verursacht eher Compilerfehler als Abstürze, aber es ist keine gute Idee, sich dafür auf den Compiler zu verlassen.

Verweise:

http://www.codingunit.com/cplusplus-tutorial-pointers-reference-and-dereference-operators

& is the reference operator and can be read as “address of”.
* is the dereference operator and can be read as “value pointed by”.

http://www.cplusplus.com/doc/tutorial/pointers/

& is the reference operator    
* is the dereference operator

http://en.wikipedia.org/wiki/Dereference_operator

The dereference operator * is also called the indirection operator.

Ich habe sie immer im umgekehrten Sinne gehört:

  • & ist der Referenzoperator – er gibt Ihnen eine Referenz (Zeiger) auf ein Objekt

  • * ist der Dereferenzierungsoperator – er nimmt eine Referenz (Zeiger) und gibt Ihnen das Objekt zurück, auf das verwiesen wird;

Benutzeravatar von ApproachingDarknessFish
Annäherung an DunkelheitFisch

Für den Anfang haben Sie sie rückwärts: & ist Referenz und * ist Dereferenzierung.

Das Referenzieren einer Variablen bedeutet den Zugriff auf die Speicheradresse der Variablen:

int i = 5;
int * p;
p = &i; //&i returns the memory address of the variable i.

Das Dereferenzieren einer Variablen bedeutet, auf die Variable zuzugreifen, die an einer Speicheradresse gespeichert ist:

int i = 5;
int * p;
p = &i;
*p = 7; //*p returns the variable stored at the memory address stored in p, which is i.
//i is now 7

  • Moment mal, die Speicheradresse der Variable i ist nicht 5, 5 ist der Wert von i. Ist es nicht? Die Speicheradresse sollte so etwas wie … 0XA234948 sein … was wir nicht wissen müssen.

    – Najana

    25. März 2013 um 8:00 Uhr


  • @dockbudu Richtig. Der Wert von i ist 5, die Speicheradresse ist ein Wert, über den wir keine Kontrolle haben (oft in Hexadezimal ausgedrückt).

    – Annäherung an DarknessFish

    25. März 2013 um 19:24 Uhr

Benutzeravatar von nagaradderKantesh
NagaradderKantesh

finden Sie die folgende Erklärung:

int main()
{
    int a = 10;// say address of 'a' is 2000;
    int *p = &a; //it means 'p' is pointing[referencing] to 'a'. i.e p->2000
    int c = *p; //*p means dereferncing. it will give the content of the address pointed by 'p'. in this case 'p' is pointing to 2000[address of 'a' variable], content of 2000 is 10. so *p will give 10. 
}

Fazit :

  1. & [address operator] dient der Referenzierung.
  2. * [star operator] wird zur Dereferenzierung verwendet.

Der Kontext, in dem sich * befindet, verwirrt manchmal die Bedeutung.

  // when declaring a function
int function(int*); // This function is being declared as a function that takes in an 'address' that holds a number (so int*), it's asking for a 'reference', interchangeably called 'address'. When I 'call'(use) this function later, I better give it a variable-address! So instead of var, or q, or w, or p, I give it the address of var so &var, or &q, or &w, or &p.   

//even though the symbol ' * ' is typically used to mean 'dereferenced variable'(meaning: to use the value at the address of a variable)--despite it's common use, in this case, the symbol means a 'reference', again, in THIS context. (context here being the declaration of a 'prototype'.) 


    //when calling a function
int main(){ 
    function(&var);  // we are giving the function a 'reference', we are giving it an 'address'
  }

Also im Rahmen von erklären a Typ wie int oder char, würden wir die verwenden Dereferenzierer ‘*’ eigentlich bedeuten die Referenz (die Adresse)was es verwirrend macht, wenn Sie eine Fehlermeldung vom Compiler sehen, die besagt: ‘expecting char*’ was nach einer Adresse fragt.

Wenn in diesem Fall das * nach a steht Typ (int, char, etc.) erwartet der Compiler die Adresse einer Variablen. Wir geben ihm dies, indem wir einen Referenzoperator verwenden, der auch als the bezeichnet wird Adresse von Operator ‘ & ‘ vor einer Variablen. Darüber hinaus erwartet der Compiler in dem Fall, den ich gerade oben erfunden habe, dass die Adresse einen Zeichenwert und keine Zahl enthält. (Typ char * == Adresse eines Wertes, der ein Zeichen hat)

int* p;
int *a;   // both are 'pointer' declarations. We are telling the compiler that we will soon give these variables an address (with &).

int c = 10;  //declare and initialize a random variable
//assign the variable to a pointer, we do this so that we can modify the value of c from a different function regardless of the scope of that function (elaboration in a second)

p = c; //ERROR, we assigned a 'value' to this 'pointer'. We need to assign an 'address', a 'reference'.
p = &c; // instead of a value such as: 'q',5,'t', or 2.1 we gave the pointer an 'address', which we could actually print with printf(), and would be something like
//so
p = 0xab33d111; //the address of c, (not specifically this value for the address, it'll look like this though, with the 0x in the beggining, the computer treats these different from regular numbers)
*p = 10; // the value of c

a = &c; // I can still give c another pointer, even though it already has the pointer variable "p"

*a = 10;
 a = 0xab33d111;

Stellen Sie sich vor, jede Variable hat eine Position (oder einen Indexwert, wenn Sie mit Arrays vertraut sind) und einen Wert. Es kann etwas gewöhnungsbedürftig sein, sich vorzustellen, dass jede Variable zwei Werte hat, wobei ein Wert ihre Position ist, die physisch mit Strom in Ihrem Computer gespeichert wird, und ein Wert, der die Menge oder den Buchstaben darstellt, den der Programmierer speichern möchte.

//Why it's used
int function(b){
    b = b + 1; // we just want to add one to any variable that this function operates on.
} 

int main(){

    int c = 1;  // I want this variable to be 3.

    function(c); 
    function(c);// I call the function I made above twice, because I want c to be 3.

     // this will return c as 1. Even though I called it twice.
     // when you call a function it makes a copy of the variable.
     // so the function that I call "function", made a copy of c, and that function is only changing the "copy" of c, so it doesn't affect the original
}
  //let's redo this whole thing, and use pointers

int function(int* b){ // this time, the function is 'asking' (won't run without) for a variable that 'points' to a number-value (int). So it wants an integer pointer--an address that holds a number.
*b = *b + 1; //grab the value of the address, and add one to the value stored at that address
}

int main(){
    int c = 1; //again, I want this to be three at the end of the program
    int *p = &c; // on the left, I'm declaring a pointer, I'm telling the compiler that I'm about to have this letter point to an certain spot in my computer. Immediately after I used the assignment operator (the ' = ') to assign the address of c to this variable (pointer in this case) p. I do this using the address-of operator (referencer)' & '.
    function(p); // not *p, because that will dereference. which would give an integer, not an integer pointer ( function wants a reference to an int called int*, we aren't going to use *p because that will give the function an int instead of an address that stores an int.

    function(&c); // this is giving the same thing as above, p = the address of c, so we can pass the 'pointer' or we can pass the 'address' that the pointer(variable) is 'pointing','referencing' to. Which is &c. 0xaabbcc1122...


      //now, the function is making a copy of c's address, but it doesn't matter if it's a copy or not, because it's going to point the computer to the exact same spot (hence, The Address), and it will be changed for main's version of c as well.

}

Innerhalb jedes einzelnen Blocks kopiert es die Variablen (falls vorhanden), die übergeben werden (über Parameter innerhalb von “()”). Innerhalb dieser Blöcke werden die Änderungen an einer Variablen an a vorgenommen Kopieren dieser Variablen verwendet die Variable dieselben Buchstaben, befindet sich aber an einer anderen Adresse (als die des Originals). Indem wir die Adresse “Referenz” des Originals verwenden, können wir eine Variable ändern, indem wir einen Block außerhalb von main oder innerhalb eines untergeordneten Elements von main verwenden.

Benutzeravatar der Community
Gemeinschaft

Referenzieren

& ist der Referenzoperator. Es verweist die Speicheradresse auf die Zeigervariable.

Beispiel:

int *p;
int a=5;
p=&a; // Here Pointer variable p refers to the address of integer variable a.

Dereferenzierung

Dereferenzierungsoperator * wird von der Zeigervariablen verwendet, um direkt auf den Wert der Variablen anstelle ihrer Speicheradresse zuzugreifen.

Beispiel:

int *p;
int a=5;
p=&a;
int value=*p; // Value variable will get the value of variable a that pointer variable p pointing to.

Die Referenz des dereferenzierten Zeigers ist auch die gleiche wie die Adresse der Variablen, auf die gezeigt wird.

Erläuterung :-

int var = 3; int * p;

p = &var;

Nehmen wir also an, die Adresse von var ist: ABCDE

dann,

p = ABCDE und &*p = ABCDE;

das heißt &* zusammenfügen, neutralisieren die Referenzierung und Dereferenzierung.


auch beim Deklarieren einer Funktion ,

die Argumente der Funktion sollten die Zeiger sein,

und in den Argumenten dieser Funktion, wenn sie in der Hauptmethode aufgerufen wird, sollte der &-Operator enthalten sein.

es ist etwas verwirrend. Aber denken Sie daran, dass int *p = &var; ist auch korrekt wie die obige Zeigerdeklaration.

  • Bitte fügen Sie keine neue Antwort hinzu, wenn Sie weitere Informationen hinzufügen möchten, verwenden Sie stattdessen die Schaltfläche Bearbeiten und bearbeiten Sie die ursprüngliche Antwort. Sie sollten diese Antwort behalten und die “kleinere Version” entfernen. Außerdem sollten Sie die Antwort bearbeiten und Ihren Code formatieren (wählen Sie und geschweifte Klammern im Editor drücken)

    – Regel

    29. November 2020 um 16:38 Uhr

1417940cookie-checkBedeutung von “Referenzieren” und “Dereferenzieren” in C

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy