Допускаются ли отрицательные индексы массива в C?

Я просто читал код и обнаружил, что человек использовал arr[-2]для доступа ко второму элементу до arr, например:

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

Это разрешено?

Я знаю, что arr[x]это то же самое, что и *(arr + x). Так arr[-2]это *(arr - 2), что , кажется , в порядке. Что вы думаете?

Это верно. Из C99 §6.5.2.1 / 2:

Определение оператора индекса [] заключается в том, что E1 [E2] идентично (* ((E1) + (E2))).

Никакой магии. Это эквивалент 1-1. Как всегда, при разыменовании указателя (*) вы должны быть уверены, что он указывает на действительный адрес.

Это допустимо, только если arrуказатель указывает на второй элемент в массиве или более поздний элемент. В противном случае это недопустимо, потому что вы будете обращаться к памяти за пределами массива. Так, например, это было бы неправильно:

int arr[10];

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

Но это было бы нормально:

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

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

Однако использование отрицательного индекса является необычным.

Звучит нормально. Однако это будет редкий случай, когда вам это понадобится на законных основаниях.

Вероятно, это arrуказывало на середину массива, следовательно, arr[-2]указывало на что-то в исходном массиве без выхода за пределы.

Я не уверен, насколько это надежно, но я только что прочитал следующее предостережение об отрицательных индексах массива в 64-битных системах (предположительно LP64): http://www.devx.com/tips/Tip/41349

Похоже, что автор говорит, что 32-битные индексы массива int с 64-битной адресацией могут привести к вычислению неверных адресов, если только индекс массива явно не повышен до 64-битного (например, через приведение ptrdiff_t). Я действительно видел ошибку его характера в версии gcc 4.1.0 для PowerPC, но я не знаю, является ли это ошибкой компилятора (т.е. должен работать в соответствии со стандартом C99) или правильным поведением (например, для индекса требуется приведение к 64 бит для правильного поведения)?

Я знаю, что на вопрос дан ответ, но я не мог удержаться от этого объяснения.

Я помню принципы построения компилятора. Предположим, что a - массив int, размер int равен 2, а базовый адрес a равен 1000.

Как a[5]будет работать ->

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

Это объяснение также является причиной того, почему отрицательные индексы в массивах работают в C.

т.е. если я получу доступ, a[-5]он даст мне

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

Он вернет мне объект в местоположении 990. С помощью этой логики мы можем получить доступ к отрицательным индексам в массиве в C.

Что касается того, зачем кому-то использовать отрицательные индексы, я использовал их в двух контекстах:

1. Имея таблицу комбинаторных чисел, в которой говорится, что comb [1] [- 1] = 0; вы всегда можете проверить индексы перед доступом к таблице, но так код выглядит чище и выполняется быстрее.

2. Ставим сантинель в начало таблицы. Например, вы хотите использовать что-то вроде

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

но тогда вы также должны проверить это iположительно.
Решение: сделать так , чтобы a[-1]это -DBLE_MAX, так что x<a[-1]всегда будет ложным.

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