Os índices de array negativos são permitidos em C?

Eu estava lendo um código e descobri que a pessoa estava usando arr[-2]para acessar o 2º elemento antes do arr, assim:

|a|b|c|d|e|f|g|
       ^------------ arr[0]
         ^---------- arr[1]
   ^---------------- arr[-2]

Isso é permitido?

Eu sei que arr[x]é o mesmo que *(arr + x). Então arr[-2]é *(arr - 2), o que parece OK. O que você acha?

Está correto. De C99 §6.5.2.1 / 2:

A definição do operador subscrito [] é que E1 [E2] é idêntico a (* ((E1) + (E2))).

Não há mágica. É uma equivalência 1-1. Como sempre, ao remover a referência de um ponteiro (*), você precisa ter certeza de que está apontando para um endereço válido.

Isso só é válido se arrfor um ponteiro que aponta para o segundo elemento em uma matriz ou um elemento posterior. Caso contrário, não é válido, porque você acessaria a memória fora dos limites do array. Então, por exemplo, isso seria errado:

int arr[10];

int x = arr[-2]; // invalid; out of range

Mas isso seria bom:

int arr[10];
int* p = &arr[2];

int x = p[-2]; // valid:  accesses arr[0]

No entanto, é incomum usar um subscrito negativo.

Parece bom para mim. No entanto, seria raro você precisar dele legitimamente.

O que provavelmente era isso arrera apontar para o meio da matriz, portanto, arr[-2]apontar para algo na matriz original sem sair dos limites.

Não tenho certeza de quão confiável isso é, mas acabei de ler a seguinte advertência sobre índices de matriz negativos em sistemas de 64 bits (LP64, presumivelmente): http://www.devx.com/tips/Tip/41349

O autor parece estar dizendo que índices de array int de 32 bits com endereçamento de 64 bits podem resultar em cálculos de endereço incorretos, a menos que o índice de array seja explicitamente promovido para 64 bits (por exemplo, por meio de uma conversão ptrdiff_t). Na verdade, vi um bug de sua natureza com a versão PowerPC do gcc 4.1.0, mas não sei se é um bug do compilador (ou seja, deve funcionar de acordo com o padrão C99) ou comportamento correto (ou seja, o índice precisa ser convertido para 64 bits para o comportamento correto)?

Sei que a pergunta foi respondida, mas não resisti em compartilhar essa explicação.

Lembro-me dos Princípios de design do compilador. Vamos supor que a seja uma matriz int e o tamanho de int seja 2 e o endereço base de a seja 1000.

Como a[5]vai funcionar ->

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

Essa explicação também é a razão pela qual índices negativos em matrizes funcionam em C.

ou seja, se eu acessar, a[-5]ele me dará

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

Ele me retornará o objeto no local 990. Por essa lógica, podemos acessar índices negativos no Array em C.

Sobre por que alguém iria querer usar índices negativos, usei-os em dois contextos:

1. Ter uma tabela de números combinatórios que informa comb [1] [- 1] = 0; você sempre pode verificar os índices antes de acessar a tabela, mas desta forma o código parece mais limpo e executa mais rápido.

2. Colocando um centinel no início de uma mesa. Por exemplo, você deseja usar algo como

    while (x < a[i]) i--;

mas então você também deve verificar se ié positivo.
Solução: faça com que a[-1]seja -DBLE_MAX, para que x<a[-1]sempre seja falso.

#include <stdio.h>

int main() // negative index
{ 
    int i = 1, a[5] = {10, 20, 30, 40, 50};
    int* mid = &a[5]; //legal;address,not element there
    for(; i < 6; ++i)
    printf(" mid[ %d ] = %d;", -i, mid[-i]);
}