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

J'ai toujours entendu utilisé dans le sens opposé:

• & est l'opérateur de référence -- il vous donne une référence (pointeur) à un objet

• * est l'opérateur de déréférencement-il faut une référence (pointeur) et permet la visée de l'objet;

trouver ci-dessous l'explication:

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

conclusion :

1. & [adresse de l'opérateur] est utilisé pour le référencement.
2. * [star opérateur] est utilisé pour de référencement .

Le contexte qui * est dans la, confond le sens parfois.

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

Alors, dans le contexte de déclarant un type comme int ou char, on pourrait utiliser les dereferencer ' * ' pour signifier la référence (l'adresse), ce qui rend confus si vous voyez un message d'erreur du compilateur en disant: 'attend char*", qui est de demander une adresse.

Dans ce cas, lorsque l' * est après un type (int, char, etc.) le compilateur attend une variable de l'adresse. Nous lui donnons cela en utilisant un opérateur de référence, alos appelé le adresse de opérateur '& ' devant une variable. Plus loin encore, dans le cas que je viens de faire ci-dessus, le compilateur s'attend à l'adresse de tenir une valeur de caractère, pas un numéro. (de type char * == adresse d'une valeur qui a un caractère)

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;

Pensez à chaque variable comme ayant une position (ou une valeur d'index si vous êtes familiarisé avec les tableaux) et d'une valeur. Il pourrait prendre un peu de s'habituer à penser à chaque variable ayant deux valeurs, une valeur, c'est la position, physiquement stocké avec de l'électricité dans votre ordinateur, et une valeur représentant quelle que soit la quantité ou de la lettre(s) le programmeur veut store.

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

}

À l'intérieur de chaque bloc, il copie les variables (le cas échéant) qui sont passés dans (via les paramètres à l'intérieur "("s). À l'intérieur de ces blocs, les changements d'une variable à un copie de cette variable, la variable utilise les mêmes lettres mais à une autre adresse (à partir de l'original). En utilisant l'adresse "de référence" de l'original, nous pouvons changer une variable à l'aide d'un bloc à l'extérieur de la principale, ou à l'intérieur d'un enfant de main.