Gli indici di matrice negativi sono consentiti in C?

Stavo solo leggendo del codice e ho scoperto che la persona stava usando arr[-2]per accedere al 2 ° elemento prima del arr, in questo modo:

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

È permesso?

So che arr[x]è lo stesso di *(arr + x). Così arr[-2]è *(arr - 2), il che sembra OK. Cosa ne pensi?

È corretto. Da C99 §6.5.2.1 / 2:

La de fi nizione dell'operatore pedice [] è che E1 [E2] è identico a (* ((E1) + (E2))).

Non c'è magia. È un'equivalenza 1-1. Come sempre, quando si dereferenzia un puntatore (*), è necessario assicurarsi che punti a un indirizzo valido.

Ciò è valido solo se arrè un puntatore che punta al secondo elemento in un array o a un elemento successivo. Altrimenti, non è valido, perché accederesti alla memoria al di fuori dei limiti dell'array. Quindi, ad esempio, questo sarebbe sbagliato:

int arr[10];

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

Ma questo andrebbe bene:

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

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

Tuttavia, è insolito utilizzare un pedice negativo.

Mi suona bene. Tuttavia, sarebbe un caso raro che ne avresti legittimamente bisogno.

Quello che probabilmente arrpuntava al centro dell'array, quindi arr[-2]puntava a qualcosa nell'array originale senza uscire dai limiti.

Non sono sicuro di quanto sia affidabile, ma ho appena letto il seguente avvertimento sugli indici di array negativi su sistemi a 64 bit (presumibilmente LP64): http://www.devx.com/tips/Tip/41349

L'autore sembra dire che gli indici di array int a 32 bit con indirizzamento a 64 bit possono comportare calcoli di indirizzi errati a meno che l'indice dell'array non venga promosso esplicitamente a 64 bit (ad esempio tramite un cast di ptrdiff_t). Ho effettivamente visto un bug della sua natura con la versione PowerPC di gcc 4.1.0, ma non so se si tratta di un bug del compilatore (cioè dovrebbe funzionare secondo lo standard C99) o di un comportamento corretto (cioè l'indice ha bisogno di un cast su 64 bit per un comportamento corretto)?

So che la domanda ha una risposta, ma non ho potuto resistere a condividere questa spiegazione.

Ricordo i principi di progettazione del compilatore, supponiamo che a sia un array int e la dimensione di int sia 2 e l'indirizzo di base per a sia 1000.

Come a[5]funzionerà ->

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

Questa spiegazione è anche il motivo per cui gli indici negativi negli array funzionano in C.

cioè se a[-5]accedo mi 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

Mi restituirà l'oggetto nella posizione 990. Con questa logica possiamo accedere agli indici negativi in ​​Array in C.

Sul perché qualcuno dovrebbe voler usare indici negativi, li ho usati in due contesti:

1. Avere una tabella di numeri combinatori che ti dice che comb [1] [- 1] = 0; puoi sempre controllare gli indici prima di accedere alla tabella, ma in questo modo il codice appare più pulito ed è più veloce.

2. Mettere un centinello all'inizio di un tavolo. Ad esempio, vuoi usare qualcosa di simile

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

ma poi dovresti anche controllare che isia positivo.
Soluzione: fai in modo che a[-1]sia -DBLE_MAXcosì, in modo che x<a[-1]sia sempre 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]);
}