C de negatif dizi indekslerine izin veriliyor mu?

Sadece bir kod okudum ve kişinin arr[-2]2. öğeye arr, şunun gibi, daha önce erişmek için kullandığını gördüm :

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

Buna izin var mı?

Bunun arr[x]ile aynı olduğunu biliyorum *(arr + x). Yani arr[-2]olduğu *(arr - 2)Tamam görünüyor. Ne düşünüyorsun?

Bu doğru. C99 §6.5.2.1 / 2'den itibaren:

Alt simge operatörünün [] tanımı, E1 [E2] 'nin (* ((E1) + (E2))) ile aynı olmasıdır.

Sihir yok. 1-1 eşdeğerdir. Her zaman olduğu gibi, bir işaretçi (*) başvurusunu kaldırırken, geçerli bir adrese işaret ettiğinden emin olmanız gerekir.

Bu yalnızca arrbir dizideki ikinci öğeyi veya sonraki bir öğeyi gösteren bir işaretçi ise geçerlidir . Aksi takdirde, dizinin sınırları dışındaki belleğe erişiyor olacağınız için geçerli değildir. Yani, örneğin, bu yanlış olur:

int arr[10];

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

Ama bu sorun olmaz:

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

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

Bununla birlikte, bir negatif alt simge kullanmak alışılmadık bir durumdur.

Bana güzel geliyor. Bununla birlikte, meşru olarak buna ihtiyaç duyacağınız nadir bir durumdur.

Muhtemelen bu arr, dizinin ortasına işaret ediyordu , dolayısıyla arr[-2]sınırların dışına çıkmadan orijinal dizideki bir şeyi işaret ediyordu .

Bunun ne kadar güvenilir olduğundan emin değilim, ancak 64-bit sistemlerdeki (muhtemelen LP64) negatif dizi indeksleri hakkındaki şu uyarıyı okudum: http://www.devx.com/tips/Tip/41349

Yazar, 64 bit adresli 32 bit int dizi indekslerinin, dizi indeksi açıkça 64 bite yükseltilmedikçe (örneğin bir ptrdiff_t dönüşümü aracılığıyla) kötü adres hesaplamalarıyla sonuçlanabileceğini söylüyor gibi görünüyor. Aslında gcc 4.1.0'ın PowerPC sürümünde doğası gereği bir hata gördüm, ancak bunun bir derleyici hatası mı (yani C99 standardına göre çalışmalı) veya doğru davranış mı (yani dizinin 64'e dönüştürülmesi gerekiyor) bilmiyorum doğru davranış için bitler)?

Sorunun cevaplandığını biliyorum ama bu açıklamayı paylaşmaya dayanamadım.

Derleyici tasarımının ilkelerini hatırlıyorum, a'nın bir int dizisi olduğunu ve int boyutunun 2 olduğunu ve a için temel adresin 1000 olduğunu varsayalım.

Nasıl a[5]çalışacak ->

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

Bu açıklama aynı zamanda dizilerdeki negatif indekslerin C de çalışmasının sebebidir.

Yani erişirsem a[-5]bana verecek

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 konumunda bana nesne döndürecektir. Bu mantıkla C'deki Array'deki negatif indekslere erişebiliriz.

Birinin neden negatif indeks kullanmak isteyeceği hakkında, onları iki bağlamda kullandım:

1. Size tarak [1] [- 1] = 0'ı söyleyen bir kombinatoryal sayılar tablosuna sahip olmak; tabloya erişmeden önce dizinleri her zaman kontrol edebilirsiniz, ancak bu şekilde kod daha temiz görünür ve daha hızlı çalışır.

2. Masanın başına bir centinel koymak. Örneğin, aşağıdaki gibi bir şey kullanmak istiyorsunuz

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

ama sonra ibunun olumlu olup olmadığını da kontrol etmelisiniz .
Çözüm: böylece bunu yapmak a[-1]olduğunu -DBLE_MAX, böylece x<a[-1]her zaman false olur.

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