Czy ujemne indeksy tablicy są dozwolone w języku C?

Właśnie czytałem kod i odkryłem, że osoba używała arr[-2]dostępu do drugiego elementu przed arr, na przykład:

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

Czy to jest dozwolone?

Wiem, że arr[x]to to samo co *(arr + x). Tak arr[-2]jest *(arr - 2), co wydaje się OK. Co myślisz?

To jest poprawne. Od C99 §6.5.2.1 / 2:

Definicja operatora indeksu [] jest taka, że ​​E1 [E2] jest identyczne z (* ((E1) + (E2))).

Nie ma magii. To jest równoważność 1-1. Jak zawsze podczas wyłuskiwania wskaźnika (*), musisz mieć pewność, że wskazuje prawidłowy adres.

Jest to poprawne tylko wtedy, gdy arrjest wskaźnikiem wskazującym na drugi element tablicy lub późniejszy element. W przeciwnym razie nie jest to poprawne, ponieważ miałbyś dostęp do pamięci poza granicami tablicy. Na przykład byłoby to błędne:

int arr[10];

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

Ale to byłoby w porządku:

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

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

Jednak użycie ujemnego indeksu dolnego jest niezwykłe.

Brzmi dobrze. Byłoby to jednak rzadkim przypadkiem, gdy byś tego potrzebował.

To prawdopodobnie arrwskazywało na środek tablicy, a więc arr[-2]wskazywało na coś w oryginalnej tablicy bez przekraczania granic.

Nie jestem pewien, na ile jest to wiarygodne, ale właśnie przeczytałem następujące zastrzeżenie dotyczące ujemnych wskaźników tablicy w systemach 64-bitowych (prawdopodobnie LP64): http://www.devx.com/tips/Tip/41349

Autor wydaje się mówić, że 32-bitowe indeksy tablicy int z 64-bitowym adresowaniem mogą skutkować złymi obliczeniami adresu, chyba że indeks tablicy jest jawnie promowany do 64 bitów (np. Przez rzutowanie ptrdiff_t). Właściwie widziałem błąd jego natury w wersji PowerPC gcc 4.1.0, ale nie wiem, czy jest to błąd kompilatora (tj. Powinien działać zgodnie ze standardem C99), czy poprawne zachowanie (tj. Indeks wymaga rzutowania na 64 bity do prawidłowego zachowania)?

Wiem, że na pytanie udzielono odpowiedzi, ale nie mogłem się powstrzymać przed podzieleniem się tym wyjaśnieniem.

Pamiętam zasady projektowania kompilatora, załóżmy, że a jest tablicą int, a rozmiar int to 2, a adres bazowy a to 1000.

Jak a[5]będzie działać ->

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

To wyjaśnienie jest również powodem, dla którego indeksy ujemne w tablicach działają w C.

tzn. jeśli uzyskam dostęp a[-5], da mi

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

Zwróci mi obiekt w lokalizacji 990. Dzięki tej logice możemy uzyskać dostęp do ujemnych indeksów w tablicy w C.

O tym, dlaczego ktoś miałby chcieć używać indeksów ujemnych, użyłem ich w dwóch kontekstach:

1. Posiadanie tabeli liczb kombinatorycznych, która mówi ci, że grzebień [1] [- 1] = 0; zawsze możesz sprawdzić indeksy przed uzyskaniem dostępu do tabeli, ale w ten sposób kod wygląda czysto i działa szybciej.

2. Umieszczenie centynela na początku stołu. Na przykład chcesz użyć czegoś takiego jak

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

ale powinieneś także sprawdzić, czy ijest pozytywny.
Rozwiązanie: uczynić go tak, że a[-1]jest -DBLE_MAXtak, że x<a[-1]zawsze będzie fałszywa.

#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]);
}