Sind negative Array-Indizes in C zulässig?

Ich habe gerade einen Code gelesen und festgestellt, dass die Person verwendet hat, arr[-2]um auf das zweite Element vor dem zuzugreifen arr, wie folgt:

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

Ist das erlaubt

Ich weiß, das arr[x]ist das gleiche wie *(arr + x). So arr[-2]ist es *(arr - 2), was in Ordnung zu sein scheint. Was denken Sie?

Das ist richtig. Ab C99 §6.5.2.1 / 2:

Die Definition des Indexoperators [] ist, dass E1 [E2] identisch ist mit (* ((E1) + (E2))).

Es gibt keine Magie. Es ist eine 1: 1-Äquivalenz. Wie immer, wenn Sie einen Zeiger (*) dereferenzieren, müssen Sie sicherstellen, dass er auf eine gültige Adresse zeigt.

Dies ist nur gültig, wenn arres sich um einen Zeiger handelt, der auf das zweite Element in einem Array oder einem späteren Element zeigt. Andernfalls ist es nicht gültig, da Sie außerhalb der Grenzen des Arrays auf Speicher zugreifen würden. Das wäre zum Beispiel falsch:

int arr[10];

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

Aber das wäre okay:

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

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

Es ist jedoch ungewöhnlich, einen negativen Index zu verwenden.

Klingt gut für mich. Es wäre jedoch ein seltener Fall, dass Sie es jedoch zu Recht benötigen würden.

Was wahrscheinlich war, arrzeigte auf die Mitte des Arrays, wodurch arr[-2]auf etwas im ursprünglichen Array gezeigt wurde, ohne die Grenzen zu überschreiten.

Ich bin mir nicht sicher, wie zuverlässig dies ist, aber ich habe gerade die folgende Einschränkung zu negativen Array-Indizes auf 64-Bit-Systemen (vermutlich LP64) gelesen: http://www.devx.com/tips/Tip/41349

Der Autor scheint zu sagen, dass 32-Bit-Int-Array-Indizes mit 64-Bit-Adressierung zu fehlerhaften Adressberechnungen führen können, es sei denn, der Array-Index wird explizit auf 64 Bit hochgestuft (z. B. über eine ptrdiff_t-Umwandlung). Ich habe tatsächlich einen Fehler seiner Art mit der PowerPC-Version von gcc 4.1.0 gesehen, aber ich weiß nicht, ob es sich um einen Compiler-Fehler handelt (dh sollte gemäß C99-Standard funktionieren) oder um ein korrektes Verhalten (dh der Index benötigt eine Umwandlung in 64) Bits für korrektes Verhalten)?

Ich weiß, dass die Frage beantwortet ist, aber ich konnte nicht widerstehen, diese Erklärung zu teilen.

Ich erinnere mich an die Prinzipien des Compiler-Designs. Nehmen wir an, a ist ein int-Array und die Größe von int ist 2, und die Basisadresse für a ist 1000.

Wie a[5]wird es funktionieren ->

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

Diese Erklärung ist auch der Grund, warum negative Indizes in Arrays in C funktionieren.

dh wenn ich darauf zugreife a[-5], gebe ich es

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

Es wird mir ein Objekt an Position 990 zurückgeben. Durch diese Logik können wir auf negative Indizes in Array in C zugreifen.

Warum jemand negative Indizes verwenden möchte, habe ich in zwei Zusammenhängen verwendet:

1. Eine Tabelle mit kombinatorischen Zahlen, aus der hervorgeht, dass Sie [1] [- 1] = 0 kämmen; Sie können Indizes immer überprüfen, bevor Sie auf die Tabelle zugreifen. Auf diese Weise sieht der Code jedoch sauberer aus und wird schneller ausgeführt.

2. Einen Centinel an den Anfang eines Tisches setzen. Zum Beispiel möchten Sie so etwas wie verwenden

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

aber dann solltest du auch überprüfen, ob das ipositiv ist.
Lösung: macht es so , dass a[-1]ist -DBLE_MAX, so dass x<a[-1]immer falsch sein wird.

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