Les index de tableau négatifs sont-ils autorisés en C?

Je lisais juste du code et j'ai trouvé que la personne utilisait arr[-2]pour accéder au 2ème élément avant le arr, comme ceci:

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

Est-ce permis?

Je sais que arr[x]c'est la même chose *(arr + x). Ainsi arr[-2]est *(arr - 2), ce qui semble OK. Qu'est-ce que tu penses?

C'est correct. À partir de C99 §6.5.2.1 / 2:

La dé fi nition de l'opérateur indice [] est que E1 [E2] est identique à (* ((E1) + (E2))).

Il n'y a pas de magie. C'est une équivalence 1-1. Comme toujours lors du déréférencement d'un pointeur (*), vous devez vous assurer qu'il pointe vers une adresse valide.

Ceci n'est valide que s'il arrs'agit d'un pointeur qui pointe vers le deuxième élément d'un tableau ou un élément ultérieur. Sinon, ce n'est pas valide, car vous accéderiez à la mémoire en dehors des limites du tableau. Donc, par exemple, ce serait faux:

int arr[10];

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

Mais ce serait bien:

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

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

Il est cependant inhabituel d'utiliser un indice négatif.

Cela me convient. Ce serait un cas rare où vous en auriez légitimement besoin.

Ce qui était probablement qui arrpointait vers le milieu du tableau, faisant ainsi arr[-2]pointer vers quelque chose dans le tableau d'origine sans sortir des limites.

Je ne sais pas à quel point cela est fiable, mais je viens de lire la mise en garde suivante concernant les indices de tableau négatifs sur les systèmes 64 bits (probablement LP64): http://www.devx.com/tips/Tip/41349

L'auteur semble dire que les indices de tableau int 32 bits avec un adressage 64 bits peuvent entraîner de mauvais calculs d'adresse à moins que l'index de tableau ne soit explicitement promu à 64 bits (par exemple via un cast ptrdiff_t). J'ai en fait vu un bogue de sa nature avec la version PowerPC de gcc 4.1.0, mais je ne sais pas si c'est un bogue du compilateur (c.-à-d. Devrait fonctionner selon la norme C99) ou un comportement correct (c.-à-d. Que l'index a besoin d'un cast en 64 bits pour un comportement correct)?

Je sais que la question est répondue, mais je n'ai pas pu résister à partager cette explication.

Je me souviens des principes de conception du compilateur, supposons que a est un tableau int et que la taille de int est 2, & l'adresse de base pour a est 1000.

Comment a[5]fonctionnera ->

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

Cette explication est également la raison pour laquelle les index négatifs dans les tableaux fonctionnent en C.

ie si j'y accède, a[-5]ça me donnera

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

Il me renverra l'objet à l'emplacement 990. Par cette logique, nous pouvons accéder aux index négatifs dans Array en C.

À propos des raisons pour lesquelles quelqu'un voudrait utiliser des index négatifs, je les ai utilisés dans deux contextes:

1. Avoir une table de nombres combinatoires qui vous indique comb [1] [- 1] = 0; vous pouvez toujours vérifier les index avant d'accéder à la table, mais de cette façon le code semble plus propre et s'exécute plus rapidement.

2. Mettre un centinel au début d'une table. Par exemple, vous souhaitez utiliser quelque chose comme

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

mais alors vous devriez également vérifier que ic'est positif.
Solution: faites en sorte que ce a[-1]soit -DBLE_MAXainsi, ce x<a[-1]sera toujours faux.

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