Como Joel aponta no podcast Stack Overflow # 34 , na linguagem de programação C (também conhecida como: K & R), há menção dessa propriedade de matrizes em C:a[5] == 5[a]

Joel diz que é por causa da aritmética dos ponteiros, mas eu ainda não entendo. Por que faza[5] == 5[a] ?

O padrão C define o []operador da seguinte maneira:

a[b] == *(a + b)

Portanto a[5], avaliará para:

*(a + 5)

e 5[a]avaliará para:

*(5 + a)

aé um ponteiro para o primeiro elemento da matriz. a[5]é o valor que está a 5 elementos mais adiante a, que é o mesmo que *(a + 5), e da matemática do ensino fundamental sabemos que esses são iguais (a adição é comutativa ).

Como o acesso ao array é definido em termos de ponteiros. a[i]é definido para significar *(a + i), que é comutativo.

Eu acho que algo está faltando nas outras respostas.

Sim, p[i]por definição é equivalente a *(p+i), o qual (porque a adição é comutativa) é equivalente a *(i+p), ao qual (novamente, pela definição do []operador) é equivalente a i[p].

(E array[i], em , o nome da matriz é implicitamente convertido em um ponteiro para o primeiro elemento da matriz.)

Mas a comutatividade da adição não é tão óbvia nesse caso.

Quando ambos os operandos são do mesmo tipo, ou mesmo de diferentes tipos numéricos que são promovidos a um tipo comum, comutatividade faz todo o sentido: x + y == y + x.

Mas, neste caso, estamos falando especificamente sobre aritmética de ponteiros, em que um operando é um ponteiro e o outro é um número inteiro. (Inteiro + inteiro é uma operação diferente, e ponteiro + ponteiro é um disparate.)

A descrição do +operador da norma C ( N1570 6.5.6) diz:

Além disso, ambos os operandos devem ter um tipo aritmético ou um operando deve ser um ponteiro para um tipo de objeto completo e o outro deve ter um tipo inteiro.

Poderia facilmente ter dito:

Além disso, ambos os operandos devem ter um tipo aritmético ou o operando esquerdo deve ser um ponteiro para um tipo de objeto completo e o operando direito deve ter um tipo inteiro.

nesse caso, ambos i + pe i[p]seria ilegal.

Em termos de C ++, realmente temos dois conjuntos de +operadores sobrecarregados , que podem ser descritos livremente como:

pointer operator+(pointer p, integer i);

e

pointer operator+(integer i, pointer p);

dos quais apenas o primeiro é realmente necessário.

Então, por que é assim?

O C ++ herdou essa definição de C, que a obteve de B (a comutatividade da indexação de matriz é explicitamente mencionada na Referência do Usuário de 1972 para B ), que a obteve de BCPL (manual de 1967), que pode muito bem ter sido obtida até idiomas anteriores (CPL? Algol?).

Portanto, a ideia de que a indexação de array é definida em termos de adição, e essa adição, mesmo de ponteiro e número inteiro, é comutativa, remonta há muitas décadas aos idiomas ancestrais de C.

Essas línguas eram muito menos tipificadas do que o C moderno. Em particular, a distinção entre ponteiros e números inteiros era frequentemente ignorada. (Os programadores C iniciais às vezes usavam ponteiros como números inteiros não assinados, antes que a unsignedpalavra - chave fosse adicionada ao idioma.) Portanto, a idéia de tornar a adição não comutativa porque os operandos são de tipos diferentes provavelmente não teria ocorrido aos projetistas dessas linguagens. Se um usuário quiser adicionar duas "coisas", sejam elas números inteiros, ponteiros ou qualquer outra coisa, não cabe ao idioma impedi-lo.

E, ao longo dos anos, qualquer alteração a essa regra quebraria o código existente (embora o padrão ANSI C de 1989 possa ter sido uma boa oportunidade).

Alterar C e / ou C ++ para exigir colocar o ponteiro à esquerda e o número inteiro à direita pode quebrar algum código existente, mas não haveria perda de potência expressiva real.

Portanto, agora temos arr[3]e 3[arr]significamos exatamente a mesma coisa, embora a última forma nunca deva aparecer fora da IOCCC .

E claro

 ("ABCD"[2] == 2["ABCD"]) && (2["ABCD"] == 'C') && ("ABCD"[2] == 'C')

A principal razão para isso foi que, nos anos 70, quando o C foi projetado, os computadores não tinham muita memória (64 KB eram muito); portanto, o compilador C não fazia muita verificação de sintaxe. Portanto, " X[Y]" foi traduzido cegamente para " *(X+Y)"

Isso também explica as sintaxes " +=" e " ++". Tudo na forma " A = B + C" tinha a mesma forma compilada. Mas, se B fosse o mesmo objeto que A, uma otimização no nível de montagem estava disponível. Mas o compilador não era brilhante o suficiente para reconhecê-lo, então o desenvolvedor teve que ( A += C). Da mesma forma, se Cfoi 1, uma otimização de nível de montagem diferente estava disponível, e novamente o desenvolvedor teve que torná-lo explícito, porque o compilador não reconhecê-lo. (Mais recentemente, compiladores fazem, portanto, essas sintaxes são praticamente desnecessárias atualmente)

Parece que ninguém mencionou o problema de Dinah com sizeof:

Você só pode adicionar um número inteiro a um ponteiro, não pode adicionar dois ponteiros juntos. Dessa forma, ao adicionar um ponteiro a um número inteiro, ou um número inteiro a um ponteiro, o compilador sempre sabe qual bit tem um tamanho que precisa ser levado em consideração.

Para responder a pergunta literalmente. Nem sempre é verdade quex == x

double zero = 0.0;
double a[] = { 0,0,0,0,0, zero/zero}; // NaN
cout << (a[5] == 5[a] ? "true" : "false") << endl;

impressões

false

Acabei de descobrir que essa sintaxe feia pode ser "útil" ou pelo menos muito divertida de se brincar quando você deseja lidar com uma matriz de índices que se referem a posições na mesma matriz. Ele pode substituir colchetes aninhados e tornar o código mais legível!

int a[] = { 2 , 3 , 3 , 2 , 4 };
int s = sizeof a / sizeof *a;  //  s == 5

for(int i = 0 ; i < s ; ++i) {  

           cout << a[a[a[i]]] << endl;
           // ... is equivalent to ... 
           cout << i[a][a][a] << endl;  // but I prefer this one, it's easier to increase the level of indirection (without loop)

}

Claro, tenho certeza de que não há nenhum caso de uso para isso no código real, mas achei interessante de qualquer maneira :)

Boa pergunta / respostas.

Só quero salientar que ponteiros e matrizes C não são os mesmos , embora neste caso a diferença não seja essencial.

Considere as seguintes declarações:

int a[10];
int* p = a;

Em a.out, o símbolo aestá em um endereço que é o início da matriz e o símbolo pem um endereço em que um ponteiro é armazenado, e o valor do ponteiro nesse local de memória é o início da matriz.

Para ponteiros em C, temos

a[5] == *(a + 5)

e também

5[a] == *(5 + a)

Por isso, é verdade que a[5] == 5[a].

Não é uma resposta, mas apenas um pouco de reflexão. Se a classe estiver sobrecarregando o operador de índice / índice, a expressão 0[x]não funcionará:

class Sub
{
public:
    int operator [](size_t nIndex)
    {
        return 0;
    }   
};

int main()
{
    Sub s;
    s[0];
    0[s]; // ERROR 
}

Como não temos acesso à classe int , isso não pode ser feito:

class int
{
   int operator[](const Sub&);
};

Tem uma explicação muito boa em A TUTORIAL ON POINTERS AND ARRAYS IN C de Ted Jensen.

Ted Jensen explicou como:

De fato, isso é verdade, ou seja, onde quer que alguém escreva, a[i]ele pode ser substituído *(a + i) sem problemas. De fato, o compilador criará o mesmo código em ambos os casos. Assim, vemos que a aritmética do ponteiro é a mesma coisa que a indexação de array. Qualquer sintaxe produz o mesmo resultado.

Isso NÃO está dizendo que ponteiros e matrizes são a mesma coisa, não são. Estamos dizendo apenas que, para identificar um determinado elemento de uma matriz, temos a opção de duas sintaxes, uma usando indexação de matriz e outra usando aritmética de ponteiro, que produzem resultados idênticos.

Agora, olhando para esta última expressão, parte dela .. (a + i), é uma adição simples usando o operador + e as regras de C declaram que essa expressão é comutativa. Isto é (a + i) é idêntico a (i + a). Assim, poderíamos escrever *(i + a)tão facilmente quanto *(a + i). Mas *(i + a)poderia ter vindo i[a]! De tudo isso vem a curiosa verdade de que se:

char a[20];

escrita

a[3] = 'x';

é o mesmo que escrever

3[a] = 'x';

Sei que a pergunta foi respondida, mas não pude resistir a compartilhar esta explicação.

Lembro-me de Principles of Compiler design, vamos assumir que aé uma intmatriz e o tamanho inté de 2 bytes, e o endereço base para aé 1000.

Como a[5]vai funcionar ->

Base Address of your Array a + (5*size of(data type for array a))
i.e. 1000 + (5*2) = 1010

Assim,

Da mesma forma, quando o código c for dividido em código de três endereços, 5[a]ele se tornará ->

Base Address of your Array a + (size of(data type for array a)*5)
i.e. 1000 + (2*5) = 1010 

Então, basicamente, ambas as instruções estão apontando para o mesmo local na memória e, portanto a[5] = 5[a],.

Essa explicação também é a razão pela qual índices negativos em matrizes funcionam em C.

ou seja, se eu acessar, a[-5]isso me dará

Base Address of your Array a + (-5 * size of(data type for array a))
i.e. 1000 + (-5*2) = 990

Ele retornará o objeto no local 990.

Em matrizes C , arr[3]e 3[arr]são as mesmas, e os seus equivalentes são notações ponteiro *(arr + 3)para *(3 + arr). Mas, ao contrário [arr]3ou [3]arrnão é correto e irá resultar em erro de sintaxe, como (arr + 3)*e (3 + arr)*não são expressões válidas. O motivo é que o operador de desreferência deve ser colocado antes do endereço gerado pela expressão, não depois do endereço.

no compilador c

a[i]
i[a]
*(a+i)

Existem diferentes maneiras de se referir a um elemento em uma matriz! (NÃO É ESTRANHO)

Um pouco de história agora. Entre outras línguas, o BCPL teve uma influência bastante importante no desenvolvimento inicial de C. Se você declarou uma matriz no BCPL com algo como:

let V = vec 10

que realmente alocou 11 palavras de memória, não 10. Normalmente, V foi o primeiro e continha o endereço da palavra imediatamente seguinte. Assim, diferentemente de C, nomear V foi para esse local e pegou o endereço do elemento zeroeth da matriz. Portanto, a indireção da matriz no BCPL, expressa como

let J = V!5

realmente precisava fazer J = !(V + 5)(usando a sintaxe BCPL), pois era necessário buscar V para obter o endereço base da matriz. Assim V!5e 5!Veram sinônimos. Como uma observação anedótica, o WAFL (Warwick Functional Language) foi escrito em BCPL, e o melhor de minha memória tendeu a usar a última sintaxe, e não a primeira, para acessar os nós usados ​​como armazenamento de dados. Concedido que isso é algo entre 35 e 40 anos atrás, então minha memória está um pouco enferrujada. :)

A inovação de dispensar a palavra extra de armazenamento e fazer com que o compilador insira o endereço base da matriz quando foi nomeado veio mais tarde. De acordo com o artigo de história da C, isso aconteceu aproximadamente na época em que as estruturas foram adicionadas a C.

Observe que !no BCPL havia um operador de prefixo unário e um operador de infixo binário, nos dois casos fazendo indiretamente. apenas que a forma binária incluía uma adição dos dois operandos antes de fazer a indireção. Dada a natureza orientada para a palavra da BCPL (e B), isso realmente fez muito sentido. A restrição de "ponteiro e número inteiro" foi necessária em C quando ganhou tipos de dados e sizeofse tornou uma coisa.

Bem, esse é um recurso que só é possível por causa do suporte ao idioma.

O compilador interpreta a[i]como *(a+i)e a expressão é 5[a]avaliada como *(5+a). Como a adição é comutativa, verifica-se que ambos são iguais. Portanto, a expressão é avaliada como true.

Em C

 int a[]={10,20,30,40,50};
 int *p=a;
 printf("%d\n",*p++);//output will be 10
 printf("%d\n",*a++);//will give an error

Ponteiro é uma "variável"

nome da matriz é um "mnemônico" ou "sinônimo"

p++;é válido, mas a++é inválido

a[2] é igual a 2 [a] porque a operação interna de ambos é

"Aritmética do ponteiro" calculada internamente como

*(a+3) é igual a *(3+a)

tipos de ponteiro

1) ponteiro para dados

int *ptr;

2) ponteiro const para dados

int const *ptr;

3) ponteiro const para dados const

int const *const ptr;

e as matrizes são do tipo (2) da nossa lista
Quando você define uma matriz de cada vez, um endereço é inicializado nesse ponteiro
Como sabemos que não podemos alterar ou modificar o valor const no nosso programa, pois gera um erro ao compilar Tempo

A principal diferença que encontrei é ...

Podemos reinicializar o ponteiro por um endereço, mas não o mesmo caso com uma matriz.

======
e voltando à sua pergunta ...
a[5]não é nada, mas *(a + 5)
você pode entender facilmente
a - contendo o endereço (as pessoas chamam de endereço base) como um tipo de ponteiro (2) em nossa lista
[]- que o operador pode ser substituível com ponteiro *.

então finalmente ...

a[5] == *(a +5) == *(5 + a) == 5[a]