Pourquoi arr [-2] n'est-il pas équivalent à -2 [arr]?

Question

 #include <iostream>
using namespace std;

int main() 
{
    int arr[3] = { 10, 20, 30 };
    cout << arr[-2] << endl;
    cout << -2[arr] << endl;        
    return 0;
}
 

Sortie:

 4196160
-30
 

Ici, arr[-2] est en dehors des limites et invalide, ce qui entraîne un comportement indéfini . Mais -2[arr] évalué à -30 . Pourquoi?

N'est-ce pas arr[-2] équivalent à -2[arr] ?

Answer 1

-2[arr] est analysé comme -(2[arr]) . En C (et en C ++, en ignorant la surcharge), les définitions de X[Y] sont *(X+Y) (voir plus de détails à ce sujet dans cette question ), ce qui signifie que 2[arr] est égal à arr[2] .

Answer 2

Le compilateur traite cette expression

-2

comme

unary_minus decimal_integer_literal

C'est-définitions des entiers littéraux ne comprennent pas les signes.

À son tour, l'expression

2[arr]

est analysé par le compilateur comme une expression postfix.

Postfix expressions ont une priorité plus élevée que unaire expressions. Ainsi, cette expression

-2[arr]

est équivalent à

- ( 2[arr] )

De sorte que le moins unaire est appliqué à la lvalue retourné par l'expression postfix 2[arr].

D'autre part, si vous avez écrit

int n = -2;

et puis

n[arr]

ensuite, cette expression serait équivalent à

arr[-2]

Answer 3

-2[arr] est équivalent à -(2[arr]) , ce qui correspond à -arr[2] . Cependant, (-2)[arr] est équivalent à arr[-2] .

En effet, E1 [E2] est identique à (* ((E1) + (E2)))

Answer 4

Le problème sous-jacent est avec la priorité de l'opérateur. En C++, l' [], c'est à dire l'Indice de l'opérateur de détenir plus de priorité (un peu semblable à choix) que l' - unary_minus de l'opérateur.

Alors, quand on écrit,

arr[-2]

Le compilateur exécute pour la première fois arr[] alors - , mais le unary_minus est enfermé dans les limites de l' [-2] si l'expression est décomposé ensemble.

Dans le,

-2[arr]

La même chose se passe mais, le compilateur exécute 2[] de la première à la n de l' - de l'opérateur de sorte qu'il finit par être -(2[arr]) pas (-2)[arr]

Votre compréhension de la notion que, arr[i] i[arr] et *(i+arr) sont tout de même est correct. Ils sont tous des expressions équivalentes.

Si vous souhaitez écrire de cette façon, écrire comme (-2)[arr]. Vous obtiendrez la même valeur pour vous.

Check this out pour l'avenir referance :http://en.cppreference.com/w/cpp/language/operator_precedence