Joel, Stack Overflow podcast # 34'te belirtildiği gibi, C Programlama Dili'nde (aka: K&R), C'deki dizilerin bu özelliğinden bahsedilmektedir:a[5] == 5[a]

Joel işaretçi aritmetiği yüzünden olduğunu söylüyor ama hala anlamıyorum. Neden oluyora[5] == 5[a] ?

C standardı []operatörü şu şekilde tanımlar :

a[b] == *(a + b)

Bu nedenle a[5]:

*(a + 5)

ve 5[a]şunları değerlendirir:

*(5 + a)

adizinin ilk öğesine bir işaretçi. a[5]5 elementten daha fazla aolan ve aynı olan değerdir *(a + 5)ve ilkokul matematiğinden bunların eşit olduğunu biliyoruz (toplama değişmeli ).

Çünkü dizi erişimi işaretçiler olarak tanımlanır. a[i]*(a + i)değişmeli anlamına gelen ortalama olarak tanımlanır .

Bence bir şey diğer cevaplar tarafından kaçırılıyor.

Evet, p[i]tanım gereği eşdeğerdir *(p+i)(eklenme değişmeli olduğu için) eşdeğerdir *(i+p), (yine []operatörün tanımı ile ) eşdeğerdiri[p] .

(Ve array[i] , dizi adı örtük olarak dizinin ilk öğesine bir işaretçi olarak dönüştürülür.)

Ancak, eklemenin değişebilirliği bu durumda çok açık değildir.

Her iki işlenen de aynı türdeyse veya ortak bir türe yükseltilen farklı sayısal türlerde olduğunda, değişebilirlik tam anlamıyla mantıklıdır: x + y == y + x .

Ancak bu durumda, özellikle bir işlenenin bir işaretçi ve diğerinin bir tam sayı olduğu işaretçi aritmetiğinden bahsediyoruz. (Tamsayı + tamsayı farklı bir işlemdir ve işaretçi + işaretçi saçmalıktır.)

C standardının +operatörün tanımı ( N1570 6.5.6):

Ek olarak, her iki işlenen de aritmetik tipe sahip olmalı ya da bir işlenen tam bir nesne tipine işaretçi ve diğeri de tamsayı tipine sahip olmalıdır.

Kolayca söyleyebileceği gibi:

Ek olarak, her iki işlenen de aritmetik tipe veya sol işlenen tam nesne tipine bir işaretçi ve sağ işlenen tamsayı tipine sahip olmalıdır.

bu durumda hem i + pve i[p]yasadışı olurdu.

C ++ terimleriyle, +gevşek bir şekilde şu şekilde tanımlanabilecek iki aşırı yüklenmiş işleç setimiz var:

pointer operator+(pointer p, integer i);

ve

pointer operator+(integer i, pointer p);

sadece birincisi gerçekten gerekli.

Öyleyse neden bu şekilde?

C ++, bu tanımı B'den alan (dizi indekslemesinin değişebilirliği açıkça 1972 Kullanıcı Referansı B'de belirtilmiştir ) C'den devralmıştır , bu da onu BCPL'den (1967 tarihli manuel) almıştır; önceki diller (CPL? Algol?).

Bu nedenle dizi indekslemesinin toplama açısından tanımlandığı ve eklemenin, bir işaretçi ve bir tamsayı bile, değişmeli olduğu fikri, C'nin ata dillerine onlarca yıl öncesine dayanır.

Bu diller, modern C'den çok daha az güçlü yazılmıştır. Özellikle, işaretçiler ve tamsayılar arasındaki ayrım genellikle göz ardı edildi. (Erken C programcıları, bazen unsignedanahtar sözcük dile eklenmeden önce işaretçileri işaretsiz tamsayılar olarak kullandılar .) Bu nedenle, ekleri değişmez yapma fikri, çünkü işlenenlerin farklı türlerde olması, muhtemelen bu dillerin tasarımcılarına gerçekleşmezdi. Bir kullanıcı iki "şey" eklemek isterse, bu "şeyler" tamsayı, işaretçi veya başka bir şey olsun, bunu önlemek dile bağlı değildir.

Yıllar geçtikçe, bu kuraldaki herhangi bir değişiklik mevcut kodu ihlal ederdi (1989 ANSI C standardı iyi bir fırsat olabilir).

İşaretçiyi sola ve sağa tamsayıyı koymayı gerektirecek şekilde C ve / veya C ++ 'ı değiştirmek varolan bazı kodları kırabilir, ancak gerçek ifade gücü kaybı olmaz.

Şimdi de aynı şeye sahibiz arr[3]ve 3[arr]anlamıyoruz, ancak ikinci form asla IOCCC dışında görünmemelidir .

Ve tabi ki

 ("ABCD"[2] == 2["ABCD"]) && (2["ABCD"] == 'C') && ("ABCD"[2] == 'C')

Bunun ana nedeni, C'nin tasarlandığı 70'lerde, bilgisayarların çok fazla belleğe sahip olmamasıydı (64KB çoktu), bu yüzden C derleyicisi çok sözdizimi kontrolü yapmadı. Dolayısıyla " X[Y]" oldukça körü körüne " *(X+Y)"

Bu aynı zamanda " +=" ve " ++" sözdizimlerini de açıklar . " A = B + C" Biçimindeki her şey aynı derlenmiş biçime sahipti. Ancak, B, A ile aynı nesne ise, bir montaj düzeyi optimizasyonu mevcuttu. Ancak derleyici bunu tanıyacak kadar parlak değildi, bu yüzden geliştiricinin ( A += C) yapması gerekiyordu . Benzer şekilde, öyleyse C, 1farklı bir montaj düzeyi optimizasyonu mevcuttu ve derleyici bunu tanımadığı için geliştirici bunu açıkça yapmak zorunda kaldı. (Son zamanlarda derleyiciler yapar, bu yüzden bu sözdizimleri bugünlerde büyük ölçüde gereksizdir)

Dinah'ın sorunu hakkında kimsenin bahsetmediği bir şey sizeof :

Bir işaretçiye yalnızca bir tamsayı ekleyebilirsiniz, birlikte iki işaretçi ekleyemezsiniz. Bu şekilde, bir tamsayıya bir işaretçi veya bir işaretçiye bir tamsayı eklerken, derleyici her zaman hangi bitin dikkate alınması gereken bir boyuta sahip olduğunu bilir.

Soruyu tam anlamıyla cevaplamak için. Her zaman doğru değildirx == x

double zero = 0.0;
double a[] = { 0,0,0,0,0, zero/zero}; // NaN
cout << (a[5] == 5[a] ? "true" : "false") << endl;

baskılar

false

Ben sadece bu çirkin sözdizimi "yararlı", ya da en azından aynı diziye pozisyonları atıfta indeksler bir dizi ile uğraşmak istediğinizde oynamak için çok eğlenceli olabileceğini öğrenmek. İç içe geçmiş köşeli parantezleri değiştirebilir ve kodu daha okunabilir hale getirebilir!

int a[] = { 2 , 3 , 3 , 2 , 4 };
int s = sizeof a / sizeof *a;  //  s == 5

for(int i = 0 ; i < s ; ++i) {  

           cout << a[a[a[i]]] << endl;
           // ... is equivalent to ... 
           cout << i[a][a][a] << endl;  // but I prefer this one, it's easier to increase the level of indirection (without loop)

}

Tabii ki, gerçek kodda bunun için bir kullanım örneği olmadığından eminim, ama yine de ilginç buldum :)

Güzel soru / cevaplar.

Sadece C işaretçi ve diziler olmadıklarını işaret etmek istiyorum aynı bu durumda fark önemli olmamasına rağmen,.

Aşağıdaki beyanları göz önünde bulundurun:

int a[10];
int* p = a;

İçinde a.out, sembol adizinin başlangıcı olan pbir adrestir ve sembol bir işaretçinin saklandığı adrestir ve bu bellek konumundaki işaretçinin değeri dizinin başlangıcıdır.

C'deki işaretçiler için,

a[5] == *(a + 5)

ve ayrıca

5[a] == *(5 + a)

Dolayısıyla a[5] == 5[a].

Bir cevap değil, sadece düşünce için yiyecek. Sınıfta aşırı yüklenmiş dizin / alt simge operatörü varsa, ifade 0[x]çalışmaz:

class Sub
{
public:
    int operator [](size_t nIndex)
    {
        return 0;
    }   
};

int main()
{
    Sub s;
    s[0];
    0[s]; // ERROR 
}

İnt sınıfına erişimimiz olmadığından bu yapılamaz:

class int
{
   int operator[](const Sub&);
};

Ted Jensen tarafından C POINTERS VE TORORLAR ÜZERİNDEKİ BİR EĞİTİM'de çok iyi bir açıklaması var .

Ted Jensen bunu şöyle açıkladı:

Aslında, bu doğrudur, yani nerede yazarsa yazsın herhangi bir sorun olmadan a[i]değiştirilebilir *(a + i). Aslında, derleyici her iki durumda da aynı kodu yaratacaktır. Böylece işaretçi aritmetiğinin dizi indeksleme ile aynı şey olduğunu görüyoruz. Her iki sözdizimi de aynı sonucu verir.

Bu işaretçiler ve dizilerin aynı şey olduğunu söylemiyor, değil. Sadece bir dizinin belirli bir elemanını tanımlamak için, biri dizi indeksleme ve diğeri de aynı sonuçları veren işaretçi aritmetiği kullanan iki sözdizimi seçeneğine sahip olduğumuzu söylüyoruz.

Şimdi, bu son ifadeye, bir kısmına .. bakmak (a + i), + operatörü ve C kurallarını kullanarak basit bir ektir, böyle bir ifadenin değişmeli olduğu. Yani (a + i) aynıdır (i + a). Böylece yazabildiğimiz *(i + a)kadar kolay yazabiliriz *(a + i). Ama *(i + a)gelebilirdi i[a]! Bunların hepsinden ilginç bir gerçek geliyorsa:

char a[20];

yazı

a[3] = 'x';

yazmakla aynı

3[a] = 'x';

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

Derleyici tasarımının ilkelerini hatırlıyorum a, bir intdizi ve boyutun int2 bayt olduğunu ve Taban adresinin a1000 olduğunu varsayalım .

Nasıl Çalışır a[5]->

Base Address of your Array a + (5*size of(data type for array a))
i.e. 1000 + (5*2) = 1010

Yani,

Benzer şekilde c kodu 3 adresli kodlara bölünürse, 5[a]->

Base Address of your Array a + (size of(data type for array a)*5)
i.e. 1000 + (2*5) = 1010 

Temel olarak her iki ifade de bellekte aynı yere işaret ediyor ve dolayısıyla a[5] = 5[a],.

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

yani erişirsem a[-5]bana

Base Address of your Array a + (-5 * size of(data type for array a))
i.e. 1000 + (-5*2) = 990

Bana 990 numaralı konumda nesne döndürecek.

Olarak Cı-diziler , arr[3]ve 3[arr]aynıdır ve bunlara karşılık gelen işaretçi açıklamalardır *(arr + 3)için *(3 + arr). Ancak tam tersine [arr]3veya [3]arrdoğru değildir ve sözdizimi hatasına neden olur (arr + 3)*ve (3 + arr)*geçerli ifadeler değildir. Nedeni, kayıttan çıkarma operatörünün, adresten sonra değil, ifadenin verdiği adresin önüne yerleştirilmesi gerektiğidir.

c derleyicisinde

a[i]
i[a]
*(a+i)

dizideki bir öğeye başvurmanın farklı yollarıdır! (TÜM WEIRD'DE DEĞİL)

Şimdi biraz tarih. Diğer diller arasında BCPL, C'nin erken gelişimi üzerinde oldukça büyük bir etkiye sahipti. BCPL'de aşağıdaki gibi bir dizi bildirdiyseniz:

let V = vec 10

aslında 10 kelimeyi değil 11 kelimeyi tahsis etti. Tipik olarak V ilk karakterdi ve hemen ardından gelen kelimenin adresini içeriyordu. Böylece C'den farklı olarak, V isimlendirmesi o konuma gitti ve dizinin sıfırıncı elemanının adresini aldı. Bu nedenle BCPL'de dizi indirimi,

let J = V!5

J = !(V + 5)dizinin temel adresini almak için V getirilmesi gerektiğinden gerçekten (BCPL sözdizimini kullanarak) yapmak zorundaydı . Böylece V!5ve5!V eşanlamlı. Bir fıkra gözlemi olarak, WAFL (Warwick Fonksiyonel Dili) BCPL'de yazılmıştır ve belleğimin en iyisi, veri depolama olarak kullanılan düğümlere erişmek için öncekinden ziyade ikinci sözdizimini kullanma eğilimindedir. Bu 35 ila 40 yıl önce bir yerden verildi, bu yüzden hafızam biraz paslı. :)

Ek depolama alanı ile dağıtım yapma ve derleyicinin adlandırıldığında dizinin temel adresini eklemesini sağlama daha sonra geldi. C tarih belgesine göre bu, C'ye yapılar eklendiğinde gerçekleşti.

Not o !BCPL bir tekli önek operatörü ve indirection yapıyor her iki durumda da bir ikili infix operatörü hem de oldu. sadece ikili biçim, dolaylı işlem yapmadan önce iki işlenenin eklenmesini içermekteydi. BCPL'nin (ve B'nin) kelime odaklı doğası göz önüne alındığında, bu aslında çok mantıklıydı. "İşaretçi ve tamsayı" kısıtlaması, veri türlerini kazandığında ve sizeofbir şey haline geldiğinde C'de gerekli hale getirildi.

Bu, yalnızca dil desteği nedeniyle mümkün olan bir özelliktir.

Derleyici, yorumlanması a[i]olarak *(a+i)ve ifade 5[a]için değerlendirir *(5+a). Toplama değişmeli olduğu için her ikisinin de eşit olduğu ortaya çıkıyor. Dolayısıyla ifade olarak değerlendirilir true.

C cinsinden

 int a[]={10,20,30,40,50};
 int *p=a;
 printf("%d\n",*p++);//output will be 10
 printf("%d\n",*a++);//will give an error

İşaretçi bir "değişken"

dizi adı "anımsatıcı" veya "eşanlamlı"

p++;geçerli ama a++geçersiz

a[2] 2 [a] 'ya eşittir, çünkü bunların her ikisindeki dahili işlem

"İşaretçi Aritmetiği" dahili olarak

*(a+3) eşittir *(3+a)

işaretçi türleri

1) Verilere İşaretçi

int *ptr;

2) Verilere Sabit İşaretçi

int const *ptr;

3) Verileri Sabitlemek İçin Sabit İşaretçi

int const *const ptr;

ve diziler listemizden (2) türünde
Ne zaman bir dizi tanımlamak tek bir seferde adres ilklendir olan bu pointer
biz bir atar oluyor çünkü biz değiştirmek veya programımıza const değerini değiştirmek olamayacağını bildiği gibi HATA derleme sırasında zaman

Bulduğum en büyük fark ...

İşaretçiyi bir adresle yeniden başlatabiliriz, ancak bir diziyle aynı durumu yeniden başlatamayız.

======
ve sorunuza geri dönme ...
a[5]hiçbir şey değildir, ancak listemizdeki (2) tür bir işaretçi gibi - adresi (insanlar temel adres olarak adlandırır) içererek *(a + 5)
kolayca anlayabilirsiniz - bu operatör işaretçi ile değiştirilebilir
a
[]* .

en sonunda...

a[5] == *(a +5) == *(5 + a) == 5[a]