Operador subscrito: []

Sintaxe

postfix-expression [ expression ]

Comentários

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

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

Geralmente, o valor representado por postfix-expression é um valor de ponteiro, como um identificador de matriz, e expression é um valor de integral (incluindo tipos enumerados). No entanto, tudo o que é necessário sintaticamente é que uma das expressões seja do tipo ponteiro e a outra seja do tipo integral. Assim, o valor integral pode estar na posição de postfix-expression e o valor do ponteiro pode estar entre colchetes na posição expression ou subscrita. 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 acima, a expressão nArray[2] é idêntica a 2[nArray]. A razão é que o resultado de uma expressão de subscrito e1[e2] é determinado por:

*((e2) + (e1))

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

double aDbl[2];

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

Uma expressão subscrita também pode ter vários subscritos, como segue:

expression1[expression2] [expression3] ...

As expressões subscritas são associadas da esquerda para a direita. A expressão subscrita mais à esquerda, expression1[expression2], é avaliada primeiro. O endereço resultante da adição de expression1 e expression2 forma uma expressão do ponteiro; expression3 é adicionada 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 seja adicionada. O operador de indireção (*) é aplicado depois que a última expressão subscrita é avaliada, a menos que o valor do ponteiro final trate de um tipo de matriz.

As expressões com vários subscritos referem-se aos 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 matriz de C++ é de array[0] a array[size - 1]. No entanto, o C++ oferece suporte a subscritos positivos e negativos. Os subscritos negativos devem estar dentro dos limites da matriz, se não estiverem, os resultados serão imprevisíveis. O código a seguir mostra os subscritos positivo e negativo da matriz:

#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 gerar 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 na metade de intArray; em virtude disso, é possível (mas perigoso) usar os índices positivo e negativo da matriz nele. Os erros de subscrito de matriz não geram erros de tempo de compilação, mas geram resultados imprevisíveis.

O operador subscrito é comutativo. Portanto, as expressões array[index] e index[array] têm garantia de serem equivalente contanto que o operador do subscrito não seja sobrecarregado (confira Operadores sobrecarregados). O primeiro formulário é a prática de codificação mais comum, mas ambas funcionam.

Confira também

Expressões pós-fixadas
Operadores internos C++, precedência e associatividade
matrizes
Matrizes unidimensionais
Matrizes multidimensionais