Operatore indice secondario: []

Sintassi

postfix-expression [ expression ]

Osservazioni:

Un'espressione di prefisso (che può anche essere un'espressione primaria) seguita dall'operatore [ ]di indice, , specifica l'indicizzazione di matrici.

Per informazioni sulle matrici gestite in C++/CLI, vedere Matrici.

In genere, il valore rappresentato da postfix-expression è un valore puntatore, ad esempio un identificatore di matrice, ed expression è un valore integrale (inclusi i tipi enumerati). Tuttavia, l'unica condizione da soddisfare dal punto di vista sintattico è che una delle espressioni sia di tipo puntatore e l'altra di tipo integrale. Di conseguenza, il valore integrale potrebbe trovarsi nella posizione postfix-expression e il valore del puntatore potrebbe trovarsi tra parentesi quadre nella posizione dell'espressione o dell'indice. Si consideri il frammento di codice riportato di seguito:

int nArray[5] = { 0, 1, 2, 3, 4 };
cout << nArray[2] << endl;            // prints "2"
cout << 2[nArray] << endl;            // prints "2"

Nell'esempio precedente l'espressione nArray[2] è identica a 2[nArray]. Il motivo è che il risultato di un'espressione e1[e2] pedice è dato da:

*((e2) + (e1))

L'indirizzo restituito dall'espressione non è e2 byte dall'indirizzo e1. L'indirizzo viene invece ridimensionato per restituire l'oggetto successivo nella matrice e2. Ad esempio:

double aDbl[2];

Gli indirizzi di aDb[0] e aDb[1] sono separati da 8 byte, ovvero le dimensioni di un oggetto di tipo double. Questa scalabilità in base al tipo di oggetto viene eseguita automaticamente dal linguaggio C++ ed è definita in Operatori additivi in cui viene discussa l'aggiunta e la sottrazione di operandi di tipo puntatore.

Un'espressione di indice può inoltre avere più indici, come nel modo seguente:

expression1 [ expression2 ] [ expression3 ] ...

Le espressioni di indice sono associate da sinistra a destra. L'espressione di indice più a sinistra, expression1 [ expression2 ], viene valutata per prima. L'indirizzo risultante dall'aggiunta di expression1 ed expression2 forma un'espressione puntatore; quindi expression3 viene aggiunta a quest'espressione puntatore per formare una nuova espressione puntatore e così via finché non è stata aggiunta l'ultima espressione di indice. L'operatore di riferimento indiretto (*) viene applicato dopo la valutazione dell'ultima espressione pedice, a meno che il valore del puntatore finale non indirizzi un tipo di matrice.

Le espressioni con più indici fanno riferimento a elementi di "matrici multidimensionali". Una matrice multidimensionale è una matrice i cui elementi sono matrici. Ad esempio, il primo elemento di una matrice tridimensionale è una matrice con due dimensioni. Nell'esempio seguente viene dichiarata e inizializzata una matrice bidimensionale di caratteri semplice:

// expre_Subscript_Operator.cpp
// compile with: /EHsc
#include <iostream>

using namespace std;
#define MAX_ROWS 2
#define MAX_COLS 2

int main() {
  char c[ MAX_ROWS ][ MAX_COLS ] = { { 'a', 'b' }, { 'c', 'd' } };
  for ( int i = 0; i < MAX_ROWS; i++ )
     for ( int j = 0; j < MAX_COLS; j++ )
        cout << c[ i ][ j ] << endl;
}

Indici positivo e negativo

Il primo elemento di una matrice è l'elemento 0. L'intervallo di una matrice C++ è compreso tra array[0] e array[size - 1]. Tuttavia, C++ supporta gli indici positivi e negativi. Gli indici negativi devono essere compresi nei limiti della matrice; in caso contrario, i risultati sono imprevedibili. Il codice seguente mostra indici di matrice positivi e negativi:

#include <iostream>
using namespace std;

int main() {
    int intArray[1024];
    for (int i = 0, j = 0; i < 1024; i++)
    {
        intArray[i] = j++;
    }

    cout << intArray[512] << endl;   // 512

    cout << 257[intArray] << endl;   // 257

    int *midArray = &intArray[512];  // pointer to the middle of the array

    cout << midArray[-256] << endl;  // 256

    cout << intArray[-256] << endl;  // unpredictable, may crash
}

L'indice negativo nell'ultima riga può generare un errore di run-time perché punta a un indirizzo 256 int posizioni inferiori in memoria rispetto all'origine della matrice. Il puntatore midArray viene inizializzato al centro di intArray. È quindi possibile (ma pericoloso) usare indici di matrice positivi e negativi su di esso. Gli errori dell'indice di matrice non generano errori in fase di compilazione, ma producono solo risultati imprevisti.

L'operatore di indice è commutativo. Pertanto, è garantito che le espressioni array[index] e index[array] siano equivalenti, purché l'operatore di pedice non sia sottoposto a overload (vedere Overloaded Operators). Il primo form è la procedura di codifica più comune, ma entrambi funzionano.

Vedi anche

Espressioni di suffissi
Operatori C++, precedenza e associazione
Matrici
Matrici unidimensionali
Matrici multidimensionali