2
votes

Comment ++ * ptr ++ serait-il évalué par le compilateur si ptr est ptr au premier élément d'un tableau statique?

Quel est l'ordre d'évaluation dans ++ * ptr ++ ? Cela change-t-il lorsque des pointeurs et des valeurs sont impliqués dans l'opération?

Si la priorité de a ++ est supérieure à * a ou ++ a code >, alors pourquoi ++ * a ++ est-il évalué comme retournant d'abord la valeur incrémentée puis en changeant le pointeur, plutôt qu'en changeant le pointeur, puis en incrémentant la valeur à l'emplacement. Réfrence pour la préséance: https://en.cppreference.com/w/cpp/language/ operator_precedence

arr = {9, 99, 999 };
int *ptr = arr;
std::cout << ++*ptr++ << '\t';
std::cout << *ptr;

Je m'attendais à ce que la sortie soit 100 100, mais la sortie réelle était de 10 99.

pointers c++ operators

1 commentaires

Au lieu d'analyser sans fin du code illisible, écrivez du code lisible.

4 Réponses :

5
votes

L'incrément de suffixe a ++ incrémente le pointeur ptr, mais retourne la copie de ptr avant l'opération (voir la différence entre préfixe / suffixe). Il peut donc être réécrit (comme indiqué dans la réponse de Quimby) en ++ (* (ptr ++)) et va comme:

ptr ++: incrémente ptr pour qu'il pointe vers 99, mais renvoie un autre pointeur qui pointe toujours vers 9
* ptr ++: déréférences, vaut 9
++ * ptr ++: incrémente la valeur pointée par le pointeur copié, ce qui signifie incrémente 9 et renvoie 10

Ici, la logique derrière l'incrémentation / décrémentation pré / post-est bien expliquée:

Les opérateurs de pré-incrémentation et de pré-décrémentation incrémentent ou décrémentent la valeur de l'objet et retournent une référence au résultat. La post-incrémentation et la post-décrémentation créent une copie de l'objet, incrémente ou décrémente la valeur de l'objet et renvoie la copie d'avant l'incrémentation ou la décrémentation.

De: https://en.cppreference.com/w/cpp/language / operator_incdec

2 commentaires

Donc, si vous deviez dire surcharger les opérateurs de pré-incrémentation et de post-incrémentation pour une classe, dire A, et faire une copie du constructeur de A, alors l'incrément de poste donnerait-il une erreur?

pourquoi le ferait-il? Lorsque vous écrivez un opérateur pour un type défini par l'utilisateur, il ne sera utilisé que lorsque vous l'appelez. BTW, je recommande de l'essayer par vous-même plutôt que de me croire :)

0
votes

Puisque vous utilisez un tableau à une seule dimension

++ * ptr fait référence à l'incrémentation du pointeur ptr à 0 élément du tableau, après avoir incrémenté la sortie pour cela sera de 10

Le suffixe ++ a la priorité la plus élevée => ++*(ptr++)

0 commentaires

1
votes

En bref, parce que ++ * ptr ++ est réécrit comme ++(*(ptr++))

Les règles du lien sont assez claires: p>

Le suffixe ++ a la priorité la plus élevée => ++*(ptr++)
Les préfixes ++ et * ont la même priorité et ils sont à droite-associatif => ++(*(ptr++))

L'expression peut également être divisée en instructions individuelles comme celle-ci:

arr = {9, 99, 999 };
int *ptr = arr;
int *ptr2 = ptr++;//ptr2 still points to the first element
int val = *ptr2; // 9
int incVal= ++val; // 10

J'espère qu'il est clair que le ptr pointe maintenant vers le deuxième élément du tableau et le résultat de l'expression est la valeur incrémentée.

0 commentaires

2
votes

Les opérateurs Postfix ont une priorité plus élevée que le préfixe donc ils BIND plus serré / premier donc: ++ * ptr ++ est identique à ++ (* (ptr ++)) qui bout jusqu'à quel opérande fonctionne sur quoi. Donc, postfix ++ sera appliqué à votre pointeur 'ptr' mais 'après' la première ligne std :: cout. Prefix ++ fonctionnera sur ptr déréférencé donc tout est identique à:

int arr[] = {9, 99, 999 };
int *ptr = arr;
++(*ptr); // 9+1=10
std::cout << *ptr << '\t';
ptr++; // now ptr points to 99
std::cout << *ptr;

0 commentaires