Operador subscrito: []

Sintaxe

postfix-expression [ expression ]

Observações

Uma expressão postfix (que também pode ser uma expressão primária) seguida pelo operador subscrito, [ ], especifica a indexação de matriz.

Para obter informações sobre matrizes gerenciadas em C++/CLI, consulte Matrizes.

Normalmente, o valor representado por postfix-expression é um valor de ponteiro, como um identificador de matriz, e expression é um valor integral (incluindo tipos enumerados). No entanto, tudo o que é exigido sintaticamente é que uma das expressões seja do tipo ponteiro e a outra seja do tipo integral. Assim, o valor integral poderia estar na posição postfix-expression e o valor do ponteiro poderia estar entre colchetes na posição de expressão ou subscrito. Considere o seguinte fragmento de código:

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

No exemplo anterior, a expressão nArray[2] é idêntica a 2[nArray]. A razão é que o resultado de uma expressão e1[e2] subscrita é dado por:

*((e2) + (e1))

O endereço gerado pela expressão não é e2 bytes do endereço e1. Em vez disso, o endereço é dimensionado para produzir o próximo objeto na matriz e2. Por exemplo:

double aDbl[2];

Os endereços de e aDb[1] estão separados por aDb[0] 8 bytes — o tamanho de um objeto do tipo double. Esse dimensionamento de acordo com o tipo de objeto é feito automaticamente pela linguagem C++ e é definido em Operadores Aditivos , onde a adição e subtração de operandos do tipo de ponteiro é discutida.

Uma expressão subscrita também pode ter vários subscritos, da seguinte forma:

expressão1[expressão2] [expressão3] ...

As expressões subscritas associam-se da esquerda para a direita. A expressão subscrita mais à esquerda, expression1[expression2], é avaliada primeiro. O endereço que resulta da adição de expression1 e expression2 forma uma expressão de ponteiro; em seguida, expression3 é adicionado a essa expressão de ponteiro para formar uma nova expressão de ponteiro e assim por diante até que a última expressão subscrita tenha sido adicionada. O operador indirection (*) é aplicado depois que a última expressão subscrita é avaliada, a menos que o valor final do ponteiro aborde um tipo de matriz.

Expressões com vários subscritos referem-se a elementos de matrizes multidimensionais. Uma matriz multidimensional é uma matriz cujos elementos são matrizes. Por exemplo, o primeiro elemento de uma matriz tridimensional é uma matriz com duas dimensões. O exemplo a seguir declara e inicializa uma matriz bidimensional simples de caracteres:

// 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;
}

Subscritos positivos e negativos

O primeiro elemento de uma matriz é o elemento 0. O intervalo de uma matriz C++ é de array[0] a array[size - 1]. No entanto, C++ suporta subscritos positivos e negativos. Os subscritos negativos devem estar dentro dos limites da matriz; se não o fizerem, os resultados são imprevisíveis. O código a seguir mostra subscritos de matriz positivos e negativos:

#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
}

O subscrito negativo na última linha pode produzir um erro em tempo de execução porque aponta para um endereço 256 int posições mais baixo na memória do que a origem da matriz. O ponteiro midArray é inicializado no meio do intArraye, portanto, é possível (mas perigoso) usar índices de matriz positivos e negativos nele. Os erros de subscrito da matriz não geram erros em tempo de compilação, mas produzem resultados imprevisíveis.

O operador subscrito é comutativo. Portanto, as expressões array[index] e index[array] são garantidamente equivalentes, desde que o operador subscrito não esteja sobrecarregado (consulte Operadores sobrecarregados). A primeira forma é a prática de codificação mais comum, mas ambas funcionam.

Ver também

Expressões Postfix
Operadores integrados C++, precedência e associatividade
Arrays
MatrizesOne-Dimensional
Matrizes Multidimensionais