Come leggi questa riga di codice?

Se hai 3 indici, allora deve essere una matrice tridimensionale. Poiché C supporta solo array frastagliati, una matrice multidimensionale viene simulata da un array frastagliato a tre livelli. In altri linguaggi di programmazione (come C #) un array multidimensionale è un oggetto che ha più dimensioni. Per accedere a un elemento dell'array sono necessari tanti indici quante sono le dimensioni.

Un array frastagliato è effettivamente una matrice di matrici di array. È una costruzione composta da molti oggetti matrice collegati in modo simile ad un albero. Poiché l'array di livello superiore di un array allocato dinamicamente può contenere riferimenti ad altri array di lunghezze diverse, è chiamato array jagged o array ragged . Una matrice allocata staticamente è sempre rettangolare. Esempio: accesso a un elemento in un array frastagliato a 3 livelli:

int x = a[2][0][4];

Ora, la tua espressione è preceduta da un & che significa "indirizzo di" quando usato come operatore unario. (Non confondere con l'operatore binario & che è l'operatore AND binario.)

L'espressione a[2][0][4] punta a (o è l'indirizzo di) un elemento dell'array dell'array dell'array. Pertanto &a[2][0][4] è un puntatore a questo indirizzo. È normale pensare a matrici bidimensionali come a righe e colonne. Ora ogni elemento in questa riga / colonna è di nuovo un array. Quindi hai un puntatore all'indirizzo di un elemento di una colonna di una riga di un array. Nel mio esempio questo è il quinto elemento della prima colonna della terza riga. Gli indici delle matrici sono a base zero, quindi a[0] punta al primo elemento.

"Puntatore" è un termine di alto livello utilizzato in C, dove "indirizzo" è un termine di basso livello che si riferisce all'implementazione. Ma entrambi indicano riferimenti a posizioni di memoria.

Supponiamo di avere un array 2d (per semplicità, il processo di dimensionalità superiore è lo stesso)

int array[3][3];

L'array visualizzato in memoria è unidimensionale, ma logicamente possiamo pensarlo in questo modo

array
----------------------------
| [0][0] | [0][1] | [0][2] |
----------------------------
| [1][0] | [1][1] | [1][2] |
----------------------------
| [2][0] | [2][1] | [2][2] |
----------------------------

Quando chiami array[1][1] , stai recuperando il valore in quella posizione (che ho scelto di seguito per essere 12)

----------------------------
|   0    |   0    |   0    |
----------------------------
|   0    |   12   |   0    |
----------------------------
|   0    |   0    |   0    |
----------------------------

Questo ci permetterebbe di costruire un codice come il seguente

int value = array[1][1];
std::cout << value << std::endl;

Output

12

Quando chiami &array[1][1] , stai recuperando il puntatore su quella posizione

Il seguente codice recupera il puntatore al "centro" dell'array

int* ptr = &array[1][1];
(*ptr) = 10;

Quale cambierebbe il valore in quella posizione in 10 . Ciò comporterebbe l'aspetto della matrice

----------------------------
|   0    |   0    |   0    |
----------------------------
|   0    |   10   |   0    |
----------------------------
|   0    |   0    |   0    |
----------------------------

Fondamentalmente, il processo per interpretare ptr = &array[1][1][1] è lo stesso, ma hai a che fare con una matrice di dimensionalità più elevata.

È il puntatore al secondo elemento dell'array in ogni dimensione. Il tuo insegnante sarebbe stato corretto se il tuo codice dicesse ptr = &array[0][0][0]

Se hai una matrice tridimensionale, le righe e le colonne non si applicano, quindi direi qualcosa del tipo:

Alla variabile ptr viene assegnato l'indirizzo del secondo elemento nella terza dimensione del secondo elemento nella seconda dimensione del secondo elemento nella prima dimensione dell'array.