¿Se permiten índices de matriz negativos en C?

Estaba leyendo un código y descubrí que la persona estaba usando arr[-2]para acceder al segundo elemento antes del arr, así:

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

eso está permitido?

Sé que arr[x]es lo mismo que *(arr + x). También lo arr[-2]es *(arr - 2), lo que parece estar bien. ¿Qué piensas?

Eso es correcto. Desde C99 §6.5.2.1 / 2:

La de fi nición del operador de subíndice [] es que E1 [E2] es idéntico a (* ((E1) + (E2))).

No hay magia. Es una equivalencia 1-1. Como siempre, cuando se elimina la referencia a un puntero (*), debe asegurarse de que apunte a una dirección válida.

Esto solo es válido si arres un puntero que apunta al segundo elemento de una matriz o un elemento posterior. De lo contrario, no es válido, porque accedería a la memoria fuera de los límites de la matriz. Entonces, por ejemplo, esto estaría mal:

int arr[10];

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

Pero esto estaría bien:

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

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

Sin embargo, es inusual utilizar un subíndice negativo.

Me suena bien. Sin embargo, sería un caso raro que lo necesitara legítimamente.

Lo que probablemente era eso arrapuntaba al medio de la matriz, por lo tanto, arr[-2]apuntaba a algo en la matriz original sin salirse de los límites.

No estoy seguro de cuán confiable es esto, pero acabo de leer la siguiente advertencia sobre los índices de matriz negativos en sistemas de 64 bits (presumiblemente LP64): http://www.devx.com/tips/Tip/41349

El autor parece estar diciendo que los índices de matriz int de 32 bits con direccionamiento de 64 bits pueden resultar en cálculos de direcciones incorrectos a menos que el índice de matriz se promueva explícitamente a 64 bits (por ejemplo, a través de una conversión ptrdiff_t). De hecho, he visto un error de su naturaleza con la versión PowerPC de gcc 4.1.0, pero no sé si es un error del compilador (es decir, debería funcionar de acuerdo con el estándar C99) o un comportamiento correcto (es decir, el índice necesita una conversión a 64 bits para un comportamiento correcto)?

Sé que la pregunta está respondida, pero no pude resistirme a compartir esta explicación.

Recuerdo los principios del diseño del compilador, supongamos que a es una matriz int y el tamaño de int es 2, y la dirección base de a es 1000.

Cómo a[5]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

Esta explicación también es la razón por la que los índices negativos en matrices funcionan en C.

es decir, si a[-5]accedo 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

Me devolverá el objeto en la ubicación 990. Mediante esta lógica, podemos acceder a índices negativos en Array en C.

Acerca de por qué alguien querría usar índices negativos, los he usado en dos contextos:

1. Tener una tabla de números combinatorios que te diga comb [1] [- 1] = 0; siempre puede verificar los índices antes de acceder a la tabla, pero de esta manera el código se ve más limpio y se ejecuta más rápido.

2. Poner un centinela al principio de una mesa. Por ejemplo, quieres usar algo como

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

pero también debes comprobar que isea ​​positivo.
Solución: haz que a[-1]sea -DBLE_MAXasí, para que x<a[-1]siempre sea 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]);
}