Come sottolinea Joel nel podcast Stack Overflow n. 34 , in C Programming Language (aka: K & R), si fa menzione di questa proprietà degli array in C:a[5] == 5[a]

Joel dice che è a causa dell'aritmetica del puntatore ma ancora non capisco. Perchéa[5] == 5[a] ?

Lo standard C definisce l' []operatore come segue:

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

Pertanto a[5]valuterà di:

*(a + 5)

e 5[a]valuterà a:

*(5 + a)

aè un puntatore al primo elemento dell'array. a[5]è il valore che è più lontano di 5 elementia , che è lo stesso di *(a + 5), e dalla matematica della scuola elementare sappiamo che sono uguali (l'addizione è commutativa ).

Perché l'accesso alla matrice è definito in termini di puntatori. a[i]è definito come medio *(a + i), che è commutativo.

Penso che qualcosa venga perso dalle altre risposte.

Sì, p[i]è per definizione equivalente a *(p+i), che (poiché l'addizione è commutativa) è equivalente a *(i+p), che (di nuovo, per definizione []dell'operatore) è equivalente a i[p].

(E in array[i], il nome dell'array viene convertito implicitamente in un puntatore al primo elemento dell'array.)

Ma la commutatività dell'addizione non è poi così ovvia in questo caso.

Quando entrambi gli operandi sono dello stesso tipo, o anche di diversi tipi numerici che sono promosso un tipo comune, commutatività rende perfettamente senso: x + y == y + x.

Ma in questo caso stiamo parlando specificamente dell'aritmetica del puntatore, in cui un operando è un puntatore e l'altro è un numero intero. (Numero intero + intero è un'operazione diversa e puntatore + puntatore è senza senso.)

La descrizione dello standard C del + dell'operatore ( N1570 6.5.6) dice:

Inoltre, entrambi gli operandi devono avere un tipo aritmetico oppure un operando deve essere un puntatore a un tipo di oggetto completo e l'altro deve avere un tipo intero.

Avrebbe potuto altrettanto facilmente dire:

Inoltre, entrambi gli operandi devono avere un tipo aritmetico oppure l' operando di sinistra deve essere un puntatore a un tipo di oggetto completo e il operando di destra deve avere un tipo intero.

nel qual caso entrambi i + p e i[p]sarebbe illegale.

In termini di C ++, abbiamo davvero due serie di +operatori sovraccarichi , che possono essere liberamente descritti come:

pointer operator+(pointer p, integer i);

e

pointer operator+(integer i, pointer p);

di cui solo il primo è veramente necessario.

Allora perché è così?

Il C ++ ha ereditato questa definizione da C, che l'ha ottenuta da B (la commutatività dell'indicizzazione di array è esplicitamente menzionata nel riferimento degli utenti a B del 1972 ), che l'ha ottenuta da BCPL (manuale del 1967), che potrebbe averlo ottenuto anche da lingue precedenti (CPL? Algol?).

Quindi l'idea che l'indicizzazione di array sia definita in termini di addizione e che l'addizione, anche di un puntatore e di un numero intero, sia commutativa, risale a molti decenni fa ai linguaggi antenati di C.

Quelle lingue erano tipizzate in modo molto meno marcato di quanto non lo sia la C moderna. In particolare, la distinzione tra puntatori e numeri interi è stata spesso ignorata. (I primi programmatori C a volte usavano i puntatori come numeri interi senza segno, prima delunsigned parola chiave fosse aggiunta al linguaggio.) Quindi l'idea di rendere l'aggiunta non commutativa perché gli operandi sono di tipi diversi probabilmente non sarebbe venuta ai progettisti di quei linguaggi. Se un utente voleva aggiungere due "cose", indipendentemente dal fatto che quelle "cose" fossero numeri interi, puntatori o qualcos'altro, non era nella lingua per impedirlo.

E nel corso degli anni, qualsiasi modifica a quella regola avrebbe infranto il codice esistente (anche se lo standard ANSI C del 1989 avrebbe potuto essere una buona opportunità).

La modifica di C e / o C ++ per richiedere il posizionamento del puntatore a sinistra e il numero intero a destra potrebbero rompere un po 'di codice esistente, ma non ci sarebbe perdita di reale potere espressivo.

Quindi ora abbiamo arr[3]e intendiamo 3[arr]esattamente la stessa cosa, sebbene quest'ultima forma non dovrebbe mai apparire al di fuori dell'IOCCC .

E naturalmente

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

La ragione principale di ciò era che negli anni '70, quando fu progettato C, i computer non avevano molta memoria (64 KB era molto), quindi il compilatore C non faceva molto controllo della sintassi. Quindi " X[Y]" è stato tradotto alla cieca in " *(X+Y)"

Questo spiega anche le sintassi " +=" e " ++". Tutto nella forma " A = B + C" aveva la stessa forma compilata. Ma se B era lo stesso oggetto di A, allora era disponibile un'ottimizzazione a livello di assieme. Ma il compilatore non era abbastanza brillante da riconoscerlo, quindi lo sviluppatore ha dovuto ( A += C). Allo stesso modo, se lo Cfosse 1, era disponibile una diversa ottimizzazione a livello di assieme e lo sviluppatore doveva renderlo esplicito, poiché il compilatore non lo riconosceva. (Più recentemente i compilatori lo fanno, quindi queste sintassi sono in gran parte inutili in questi giorni)

Una cosa che nessuno sembra aver menzionato del problema di Dinah con sizeof:

Puoi solo aggiungere un numero intero a un puntatore, non puoi aggiungere due puntatori insieme. In questo modo quando si aggiunge un puntatore a un numero intero o un numero intero a un puntatore, il compilatore sa sempre quale bit ha una dimensione che deve essere presa in considerazione.

Per rispondere alla domanda alla lettera. Non è sempre verox == x

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

stampe

false

Ho appena scoperto che questa brutta sintassi potrebbe essere "utile", o almeno molto divertente con cui giocare quando si desidera gestire una matrice di indici che si riferiscono a posizioni nella stessa matrice. Può sostituire parentesi quadre nidificate e rendere il codice più leggibile!

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)

}

Certo, sono abbastanza sicuro che non ci sia un caso d'uso per questo nel codice reale, ma l'ho trovato comunque interessante :)

Bella domanda / risposte.

Voglio solo sottolineare che i puntatori e le matrici C non sono gli stessi , anche se in questo caso la differenza non è essenziale.

Considera le seguenti dichiarazioni:

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

In a.out, il simbolo si atrova su un indirizzo che è l'inizio dell'array e il simbolo si ptrova su un indirizzo in cui è memorizzato un puntatore e il valore del puntatore in quella posizione di memoria è l'inizio dell'array.

Per i puntatori in C, abbiamo

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

e anche

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

Quindi è vero che a[5] == 5[a].

Non una risposta, ma solo uno spunto di riflessione. Se la classe presenta un operatore indice / indice sovraccarico, l'espressione 0[x]non funzionerà:

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

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

Dal momento che non abbiamo accesso alla classe int , questo non può essere fatto:

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

Ha un'ottima spiegazione in TUTORIAL SUI PUNTATORI E SUGLI ARRAY IN C di Ted Jensen.

Ted Jensen lo ha spiegato come:

In realtà, questo è vero, cioè ovunque si scriva a[i]può essere sostituito*(a + i) senza problemi. In effetti, il compilatore creerà lo stesso codice in entrambi i casi. Quindi vediamo che l'aritmetica del puntatore è la stessa cosa dell'indicizzazione di array. Entrambe le sintassi producono lo stesso risultato.

Questo NON sta dicendo che i puntatori e le matrici siano la stessa cosa, non lo sono. Stiamo solo dicendo che per identificare un dato elemento di un array abbiamo la scelta di due sintassi, una che usa l'indicizzazione dell'array e l'altra che usa l'aritmetica del puntatore, che producono risultati identici.

Ora, guardando quest'ultima espressione, parte di essa .. (a + i), è una semplice aggiunta che utilizza l'operatore + e le regole di C affermano che tale espressione è commutativa. Cioè (a + i) è identico a (i + a). Così potremmo scrivere *(i + a)con la stessa facilità *(a + i). Ma *(i + a)potrebbe venire i[a]! Da tutto ciò deriva la curiosa verità che se:

char a[20];

scrittura

a[3] = 'x';

è lo stesso della scrittura

3[a] = 'x';

So che la domanda ha una risposta, ma non ho resistito alla condivisione di questa spiegazione.

Ricordo i principi della progettazione del compilatore, supponiamo che asia un intarray e la dimensione intsia di 2 byte e l'indirizzo di base per asia 1000.

Come a[5]funzionerà ->

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

Così,

Allo stesso modo, quando il codice c è suddiviso in un codice a 3 indirizzi, 5[a]diventerà ->

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

Quindi, in sostanza, entrambe le istruzioni puntano alla stessa posizione in memoria e quindi, a[5] = 5[a] .

Questa spiegazione è anche il motivo per cui gli indici negativi negli array funzionano in C.

cioè se a[-5]accedo mi darà

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

Mi restituirà l'oggetto nella posizione 990.

In matrici C , arr[3]e 3[arr]sono uguali, e le notazioni puntatore equivalenti *(arr + 3)a *(3 + arr). Ma al contrario [arr]3o [3]arrnon è corretto e si tradurrà in un errore di sintassi, in quanto (arr + 3)*e (3 + arr)*non sono espressioni valide. Il motivo è che l'operatore di riferimento deve essere posizionato prima dell'indirizzo fornito dall'espressione, non dopo l'indirizzo.

nel compilatore c

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

sono diversi modi per fare riferimento a un elemento in un array! (NON A TUTTI I WEIRD)

Un po 'di storia ora. Tra le altre lingue, BCPL ha avuto un'influenza abbastanza importante sullo sviluppo iniziale di C. Se hai dichiarato un array in BCPL con qualcosa del tipo:

let V = vec 10

che in realtà allocava 11 parole di memoria, non 10. Tipicamente V era la prima e conteneva l'indirizzo della parola immediatamente successiva. Quindi, diversamente da C, la denominazione di V è andata in quella posizione e ha preso l'indirizzo dell'ennesimo elemento dell'array. Pertanto indiretta dell'array in BCPL, espresso come

let J = V!5

doveva davvero fare J = !(V + 5)(usando la sintassi BCPL) poiché era necessario recuperare V per ottenere l'indirizzo di base dell'array. Così V!5e5!V erano sinonimi. Come osservazione aneddotica, WAFL (Warwick Functional Language) è stato scritto in BCPL, e al meglio della mia memoria tendeva a usare quest'ultima sintassi anziché la prima per accedere ai nodi usati come memoria dei dati. Concesso questo proviene da qualche parte tra 35 e 40 anni fa, quindi la mia memoria è un po 'arrugginita. :)

L'innovazione di dispensare con la parola di archiviazione aggiuntiva e di avere il compilatore inserire l'indirizzo di base dell'array quando è stato nominato è venuto dopo. Secondo il documento di storia C, ciò accadde all'incirca nel momento in cui le strutture furono aggiunte a C.

Si noti che !in BCPL era sia un operatore con prefisso unario che un operatore con infissione binaria, in entrambi i casi facendo riferimento indiretto. solo che il modulo binario includeva un'aggiunta dei due operandi prima di eseguire la direzione indiretta. Data la natura orientata alle parole di BCPL (e B), questo in realtà aveva molto senso. La restrizione di "puntatore e numero intero" è stata resa necessaria in C quando ha acquisito i tipi di dati ed è sizeofdiventata una cosa.

Bene, questa è una funzione che è possibile solo grazie al supporto linguistico.

Il compilatore interpreta a[i]come *(a+i)e l'espressione 5[a]valuta *(5+a). Poiché l'addizione è commutativa, si scopre che entrambi sono uguali. Quindi l'espressione valuta true.

In 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

Il puntatore è una "variabile"

il nome dell'array è "mnemonico" o "sinonimo"

p++;è valido ma a++non è valido

a[2] è uguale a 2 [a] perché l'operazione interna su entrambi è

"Puntatore aritmetico" calcolato internamente come

*(a+3) è uguale a *(3+a)

tipi di puntatore

1) puntatore ai dati

int *ptr;

2) const puntatore ai dati

int const *ptr;

3) puntatore const a const const

int const *const ptr;

e gli array sono del tipo di (2) dal nostro elenco
Quando si definisce un array alla volta un indirizzo viene inizializzato in quel puntatore.
Come sappiamo che non possiamo cambiare o modificare il valore const nel nostro programma perché genera un ERRORE alla compilazione tempo

La principale differenza che ho trovato è ...

È possibile inizializzare nuovamente il puntatore tramite un indirizzo ma non lo stesso caso con un array.

======
e torna alla tua domanda ...
a[5]non è altro *(a + 5)
che puoi capire facilmente
a - contenendo l'indirizzo (la gente lo chiama come indirizzo di base) proprio come un (2) tipo di puntatore nel nostro elenco
[]- quell'operatore può essere sostituibile con puntatore *.

così finalmente ...

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