sens de “référencement” et “déréférencement”

J’ai lu différentes choses sur Internet et je me suis trompé, car chaque site Web dit des choses différentes.

En parlant de C.

J’ai lu à propos de * opérateur de référencement et opérateur de déréférencement; ou que le référencement signifie que le pointeur pointe sur une variable et que le déréférencement accède à la valeur de la variable pointée par le pointeur. Donc j’ai été confus.

Puis-je obtenir une explication simple mais complète sur le “référencement et le dé-référencement”?

Référencer signifie prendre l’adresse d’une variable existante (en utilisant &) pour définir une variable de pointeur. Pour être valide, un pointeur doit être défini sur l’adresse d’une variable du même type que le pointeur, sans l’astérisque:

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

Déréférencer un pointeur signifie utiliser l’opérateur * (caractère astérisque) pour accéder à la valeur stockée dans un pointeur: NOTE: La valeur stockée à l’adresse du pointeur doit être une valeur DU TYPE DE TYPE comme type de variable du pointeur “point” à, mais il n’y a aucune garantie que ce soit le cas, sauf si le pointeur a été défini correctement. Le type de variable sur lequel pointe le pointeur est le type moins l’astérisque le plus à l’extérieur.

 int n1; n1 = *p1; 

Le déréférencement non valide peut ou non provoquer des accidents:

  • Toute déréférencement d’un pointeur non initialisé peut entraîner un blocage
  • Le déréférencement avec un type non valide risque de provoquer un blocage.
  • Le fait de déréférencer un pointeur sur une variable qui a été allouée de manière dynamic et a été désallouée par la suite peut provoquer un blocage
  • Le fait de déréférencer un pointeur sur une variable hors de scope peut également entraîner un blocage.

Le référencement invalide est plus susceptible de causer des erreurs de compilation que des pannes, mais ce n’est pas une bonne idée de compter sur le compilateur pour cela.

Les références:

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. 

Je les ai toujours entendus utilisés dans le sens opposé:

  • & est l’opérateur de référence – il vous donne une référence (pointeur) à un object

  • * est l’opérateur de déréférencement – il prend une référence (pointeur) et vous renvoie l’object référencé;

Pour commencer, vous les avez en arrière: & is reference et * est dereference.

Référencer une variable signifie accéder à l’adresse mémoire de la variable:

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

Déréférencer une variable signifie accéder à la variable stockée à une adresse mémoire:

 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 

trouver l’explication ci-dessous:

 int main() { int a = 10;// say address of 'a' is 2000; int *p = &a; //it means 'p' is pointing[referencing] to 'a'. ie 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. } 

conclusion :

  1. & [opérateur d’adresse] est utilisé pour le référencement.
  2. * [opérateur écanvas] est utilisé pour le dé-référencement.

Le référencement

& est l’opérateur de référence. Il renverra l’adresse mémoire à la variable de pointeur.

Exemple:

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

Déréférencer

Dereference operator * est utilisé par la variable pointeur pour accéder directement à la valeur de la variable au lieu de son adresse mémoire.

Exemple:

 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. 

Le contexte dans lequel se trouve * confond parfois le sens.

  // 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' } 

Donc, dans le contexte de la déclaration d’ un type tel que int ou char, nous utiliserions le dereferencer ‘*’ pour signifier la référence (l’adresse) , ce qui rend confus si un message d’erreur du compilateur dit: ‘ char * ‘qui demande une adresse.

Dans ce cas, lorsque le * est après un type (int, char, etc.), le compilateur attend l’adresse d’une variable. Nous lui donnons ceci en utilisant un opérateur de référence, alos appelé l’ adresse de l’ opérateur ‘&’ avant une variable. Encore plus loin, dans le cas que je viens de inventer, le compilateur s’attend à ce que l’adresse contienne une valeur de caractère, pas un nombre. (type char * == adresse d’une valeur qui a un caractère)

 int* p; int *a; // both are 'pointer' declarations. We are telling the comstackr 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; 

Considérez chaque variable comme ayant une position (ou une valeur d’index si vous êtes familier avec les tableaux) et une valeur. Cela peut prendre du temps pour penser que chaque variable a deux valeurs, une valeur étant sa position, stockée physiquement avec de l’élecsortingcité dans votre ordinateur, et une valeur représentant la quantité ou la lettre que le programmeur veut stocker.

 //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 comstackr 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. } 

À l’intérieur de chaque bloc, il copie les variables (le cas échéant) transmises (via les parameters dans “()” s). Dans ces blocs, les modifications apscopes à une variable sont apscopes à une copie de cette variable, la variable utilise les mêmes lettres mais se trouve à une adresse différente (de l’original). En utilisant l’adresse “référence” de l’original, on peut changer une variable en utilisant un bloc en dehors de main, ou à l’intérieur d’un enfant de main.