Incrémentation de pointeur (ptr ++) et (* ptr ++)

Je revoyais des indicateurs lorsque j’avais ce doute.

int *ptr; int arr[5] = {10,20,30,40,50}; ptr = &arr[0]; 

Maintenant printf("Value: %d",*ptr); imprimerait 10

si je fais:

 ptr++; printf("Value: %d",*ptr); 

le résultat serait: 20

De même si je le fais:

 *ptr++; printf("Value: %d",*ptr); 

le résultat est de: 30

Mais

 printf("Value: %d",++*ptr); 

me donne 31

Je pensais que puisque ptr est de type int lorsque je l’incrémente, il saute 4 octets à l’emplacement de mémoire suivant. Mais pourquoi affiche-t-il le même comportement pour *ptr++ et ptr++ et non pour ++*ptr ?

Le premier extrait est évident: il ptr ce que pointe ptr , c’est-à-dire 10.

La seconde déplace le pointeur en avant d’un élément, qui pointe ensuite sur l’élément suivant, c’est-à-dire 20.

Le troisième extrait est exactement identique au précédent, car sa première instruction incrémente le pointeur et renvoie la valeur non incrémentée, qui est déréférencée, mais son résultat est ignoré; ce qui est déréférencé dans le printf est le pointeur incrémenté, qui pointe maintenant à 30.

Le dernier extrait est différent: ++*ptr is ++(*ptr) ; *ptr dereferences ptr (qui pointe déjà à 30 ), donnant 30, et ++ incrémente cette valeur, qui devient 31.

En raison de la priorité .

  • *ptr++ est identique à *(ptr++) , le pointeur est incrémenté, mais sa valeur précédente est déréférencée.
  • ptr++ est identique à, bien, ptr++ .
  • ++*ptr est identique à ++(*ptr) , c’est-à-dire qu’il incrémente l’object pointé, pas le pointeur.

Quand vous faites * ptr++ , vous faites réellement * (ptr++) , donc le pointeur est incrémenté, pas la variable vers laquelle il pointe

Quand ++ *ptr , c’est en fait ++(* ptr) , donc il incrémente la valeur renvoyée par le pointeur

L’ordre de priorité C de priorité élevée:

()
++
* & pour les pointeurs
* /
+ –

alors,

  *ptr++ equivlant to *(ptr++) ++*ptr equivlant to ++(*ptr) 

et pour cette ligne * ptr ++; cela n’incrémentera que le pointeur ptr.

Le truc, c’est que lorsque les deux opérateurs sont unaires, l’associativité s’effectue de droite à gauche.

* ptr ++ -> premier pointeur d’incrémentation à l’emplacement suivant, puis déréférence de la valeur à cet emplacement.

De même * ++ ptr -> premier pointeur d’incrémentation puis déréférencement.

++ * ptr -> premier déréférencer la valeur à ptr puis incrémenter la valeur.