value - electron charge in ev




O que é '-1 (4)

A primeira coisa a descobrir é a precedência. Ou seja, [] tem precedência mais alta que os operadores unários, então -1[p] é igual a -(1[p]) , não (-1)[p] . Então, estamos pegando o resultado de 1[p] e negando-o.

x[y] é igual a *(x+y) , então 1[p] é igual a *(1+p) , que é igual a *(p+1) , que é igual a p[1] .

Então, pegamos o elemento um depois de onde p aponta, então o terceiro elemento da array , ou seja, 3, e depois o negamos, o que nos dá -3 .

Esta pergunta já tem uma resposta aqui:

Hoje eu tropecei em um enigma em C que ganhou uma nova surpresa para mim.

Eu não achei que -1 [p] no exemplo abaixo fosse compilado, mas foi. De fato, x acaba sendo -3.

    int x;
    int array[] = {1, 2, 3};
    int *p = &array[1];
    x = -1[p]

Procurei na internet algo como -1 [ponteiro], mas não consegui encontrar nada. Ok, é difícil inserir a consulta de pesquisa correta, admito. Quem sabe por que -1 [p] compila e X se torna -3?


De acordo com o padrão C (operadores Postfix 6.5.2), o operador subscrito é definido da seguinte maneira

postfix-expression [ expression ]

Portanto, antes dos colchetes, deve haver uma expressão postfix.

Nesta declaração de expressão

x = -1[p];

são usadas a expressão postfix 1 (que é ao mesmo tempo uma expressão primária), a expressão postfix 1[p] (que é o operador subscrito) e o operador unário - leve em consideração que quando o compilador divide um programa em tokens as constantes inteiras são consideradas como símbolos sem o sinal de menos. menos é um token separado.

Portanto, a declaração pode ser reescrita como

x = -( 1[p] );

porque uma expressão postfix tem uma prioridade mais alta que uma expressão unária.

Vamos considerar primeiro a sub-expressão 1[p] do postfix 1[p]

De acordo com o padrão C (6.5.2.1 Matriz de assinatura)

2 Uma expressão postfix seguida por uma expressão entre colchetes [] é uma designação subscrita de um elemento de um objeto de matriz. A definição do operador subscrito [] é que E1 [E2] é idêntico a (* ((E1) + (E2))). Devido às regras de conversão que se aplicam ao operador binário +, se E1 for um objeto de matriz (equivalentemente, um ponteiro para o elemento inicial de um objeto de matriz) e E2 for um número inteiro, E1 [E2] designará o E2-ésimo elemento de E1 (contando a partir de zero).

Portanto, essa subexpressão é avaliada como *( ( 1 ) + ( p ) ) e é a mesma que *( ( p ) + ( 1 ) ).

Assim, a afirmação acima

x = -1[p];

é equivalente a

x = -p[1];

e produzirá -3 , porque o ponteiro p aponta para o segundo elemento da matriz devido à instrução

int *p = &array[1];

e, em seguida, a expressão p[1] gera o valor do elemento após o segundo elemento da matriz. Em seguida, o operador unário - é aplicado.


O que acontece aqui é realmente interessante.

p [n] significa *(p+n) . É por isso que você vê 3, porque "p" aponta para o array [1], que é 2, e -p [1] é interpretado como -(*(p+1)) que é -3.


este

int array[] = {1, 2, 3};

parece

array[0]   array[1]  array[2]
 --------------------------
|     1   |    2    |   3  | 
 --------------------------
 0x100     0x104     0x108   <-- lets assume 0x100 is base address of array
array

Em seguida, quando você gosta

int *p = &array[1];

o ponteiro inteiro p aponta para o endereço da array[1] ou seja, 0x104 . Parece

array[0]   array[1]  array[2]
 --------------------------
|     1   |    2    |   3  | 
 --------------------------
 0x100     0x104     0x108   <-- lets assume 0x100 is base address of array
             |
            p holds 0x104

E quando você gosta

x = -1[p]

-1[p] é equivalente a -(1[p]) ou seja -(p[1]) . parece

-(p[1]) ==> -(*(p + 1*4)) /* p holds points to array[1] i.e 0x104 */
        ==> -(*(0x104 + 4))
        ==> -(*(0x108)) ==> value at 0x108 is 3
        ==> prints -3




postfix-operator