Comment parsingr la priorité dans la situation suivante.
for (i=0; i<20; i++) { *array_p++ = i*i; printf("%d\n",*arr++); }
en quoi le code suivant est-il différent d’en haut
for (int i=0; i<20; i++) { *arr = i*i; printf("%d\n",*arr); arr++; printf("%d\n",(int )arr); }
J’attends la même sortie mais les sorties sont différentes pour la valeur * arr
Les opérateurs Postfix ont une priorité plus élevée que les opérateurs unaires, donc *x++
est analysé comme *(x++)
; le résultat de l’expression x++
(qui est x
) est déréférencé.
Dans le cas de *++x
, *
et ++
sont des opérateurs unaires et ont donc la même priorité. Les opérateurs sont donc appliqués de gauche à droite, ou *(++x)
; le résultat de l’expression ++x
(qui est x + sizeof *x
) est déréférencé.
Citant Wikipedia , postfix ++ se lie avant unary *. Cela signifie que vous avez *(arr++)
. Par exemple, dans l’expression *arr++ = 5
, *arr
est atsortingbué à 5, puis arr
est incrémenté.
Dans le K & R, cette astuce est utilisée pour écrire une version concise de memcpy. C’est quelque chose comme:
while (--size) *dest++ = *src++;
Je posterai le bon exemple après mon retour à la maison ce soir.
Edit: Apparemment, seul postfix ++ a une priorité plus élevée. Wikipedia dit que le préfixe ++ a la même priorité.
Il est facile de se souvenir de ce qui a préséance lorsque vous envisagez l’incrément de préfixe.
qu’est-ce qui a préséance ici?
* ++ tableau = x; // Assez évident
les mêmes règles de priorité s’appliquent à l’expression postfixe, donc c’est plutôt facile.
Il en va de même pour l’opérateur de casting.
(somestruct *) x + 1;
d’abord le casting est fait depuis si ce n’était pas ce qui suit n’aurait pas de sens
x + (int) 1;
Dans le premier extrait de code,
for (i=0; i<20; i++) { *array_p++ = i*i; printf("%d\n",*arr++); }
array_ptr est incrémenté en premier, c'est-à-dire adresse, puis la valeur calculée à partir de i * i est assignée à * array_ptr car l'évaluation prend dans l'ordre de droite à gauche, c'est-à-dire * (array_ptr ++).
Dans le deuxième exemple d'extrait de code,
for (int i=0; i<20; i++) { *arr = i*i; printf("%d\n",*arr); arr++; printf("%d\n",(int )arr); }
la valeur calculée à partir de i * i est d'abord calculée et affectée à * arr, puis le pointeur pointant vers arr est incrémenté.
Il existe donc une différence de valeur entre les 2 extraits de code.
Les opérateurs ++ et * ont la même priorité ( postfix or prefix
). Cependant, dans ce cas, l’associativité est de droite à gauche. donc dans des cas comme
*ptr++ ==> *(ptr++) *++ptr ==> *(++ptr) ++*ptr ==> ++(*ptr)
Ce lien devrait vous donner plus d’informations sur la préséance des opérateurs et leur associativité. http://www.isthe.com/chongo/tech/comp/c/c-precedence.html