Bir sayının karesini hesaplamak için bu yolu anlayamıyorum

Bir sayının karesini hesaplayan bir işlev buldum:

int p(int n) {
    int a[n]; //works on C99 and above
    return (&a)[n] - a;
}

N ² değerini döndürür . Soru şu, bunu nasıl yapıyor? Biraz testlerden sonra, ben arasında bulundu (&a)[k]ve (&a)[k+1]bir sizeof(a)/ sizeof(int). Neden?

Açıkçası bir hack ... ama *operatörü kullanmadan bir sayı karesi alma yolu (bu bir kodlama yarışması gereksinimi idi).

(&a)[n] 

intkonumdaki bir işaretçiye eşdeğerdir

(a + sizeof(a[n])*n)

ve böylece tüm ifade

  (&a)[n] -a 

= (a + sizeof(a[n])*n -a) /sizeof(int)

= sizeof(a[n])*n / sizeof(int)
= sizeof(int) * n * n / sizeof(int)
= n * n

Bu hack'i anlamak için, önce işaretçi farkını anlamalısınız, yani, aynı dizinin öğelerini işaret eden iki işaretçi çıkarıldığında ne olur ?

Bir işaretçi diğerinden çıkarıldığında, sonuç işaretçiler arasındaki mesafedir (dizi öğelerinde ölçülür). Yani, eğer pişaret eder a[i]ve qişaret ederse a[j], o p - qzaman eşittiri - j .

C11: 6.5.6 Katkı operatörleri (s9):

İki işaretçi çıkarıldığında , her ikisi de aynı dizi nesnesinin öğelerini veya dizi nesnesinin son öğesinin ötesini işaret eder; sonuç, iki dizi öğesinin aboneliklerinin farkıdır . [...].
Başka bir deyişle, ifadeler Pve Qsırasıyla bir dizi nesnesinin i-th ve j-th öğelerini gösteriyorsa , ifadenin (P)-(Q), değerini−j türdeki bir nesneye uyması koşuluyla değeri olur ptrdiff_t.

Şimdi işaretçi için dizi adı dönüşüm farkında olduğunuzu umuyorum, aişaretçi dizinin ilk öğesine dönüştürür a. &atüm bellek bloğunun adresidir, yani bir dizi adresidir a. Aşağıdaki şekil anlamanıza yardımcı olacaktır ( _{ayrıntılı açıklama için bu cevabı okuyun} ):

Bu, neden ave &aaynı adrese ve (&a)[i]i ^th dizisinin adresinin (adresiyle aynı boyutta a) nasıl olduğunu anlamanıza yardımcı olacaktır .

Yani, açıklama

return (&a)[n] - a; 

eşittir

return (&a)[n] - (&a)[0];  

ve bu fark işaretçiler arasındaki (&a)[n]ve her bir elemanın dizisi (&a)[0]olan elemanların sayısını verecektir . Bu nedenle, toplam dizi elemanları = ^2'dir . nn intn*nn

NOT:

C11: 6.5.6 Katkı operatörleri (s9):

İki işaretçi çıkarıldığında, her ikisi de aynı dizi nesnesinin öğelerini veya dizi nesnesinin son öğesinin ötesini işaret eder ; sonuç, iki dizi öğesinin aboneliklerinin farkıdır. Sonucun boyutu uygulama tanımlıdır ve türü (işaretli bir tamsayı türü) başlıkta ptrdiff_ttanımlanır <stddef.h>. Sonuç bu tür bir nesnede gösterilemiyorsa, davranış tanımsızdır.

Bu yana (&a)[n]bir dizi objenin son öğe geçen aynı dizi nesne veya bir elemanlarına de nokta, (&a)[n] - aaçılmasına neden olur tanımsız davranış .

Ayrıca işlevin dönüş türünü değiştirmek için daha iyi, dikkat petmek ptrdiff_t.

abir (değişken) dizisidir n int.

&a, (değişken) dizisinin göstergesidir n int.

(&a)[1]bir gösterici intbir intson dizi elemanı geçmiş. Bu işaretçi n intöğeden sonraki öğedir &a[0].

(&a)[2]bir gösterici intbir intiki dizi son dizi elemanı geçmiş. Bu işaretçi 2 * n intöğeden sonraki öğedir &a[0].

(&a)[n]bir gösterici intbir intson dizi elemanı son ndizileri. Bu işaretçi n * n intöğeden sonraki öğedir &a[0]. Sadece çıkart &a[0]ya da asende var n.

Tabii ki bu, (&a)[n]dizinin içinde veya son dizi öğesinin ötesinde (işaretçi aritmetiği C kurallarının gerektirdiği gibi) geçmediği için makinenizde çalışsa bile teknik olarak tanımlanmamış bir davranıştır .

Aynı dizinin iki öğesini işaret eden iki işaretçiniz varsa, farkı bu işaretçiler arasındaki öğe sayısını verecektir. Örneğin, bu kod snippet'i 2 çıktısı verir.

int a[10];

int *p1 = &a[1];
int *p2 = &a[3];

printf( "%d\n", p2 - p1 ); 

Şimdi ifadeyi düşünelim

(&a)[n] - a;

Bu ifadede atürü vardır int *ve ilk öğesine işaret eder.

İfadenin &atürü vardır int ( * )[n]ve görüntülenen iki boyutlu dizinin ilk sırasına işaret eder. Değeri, atürlerin farklı olmasına rağmen değeriyle eşleşir .

( &a )[n]

Bu görüntülenen iki boyutlu dizinin n. öğesidir ve türü vardır int[n]Görüntülenen dizinin n. satırdır. İfadede (&a)[n] - a, ilk öğesinin adresine dönüştürülür ve "int *" türüne sahiptir.

Yani arasında (&a)[n]ve an öğesinin n sırası vardır. Yani fark eşit olacaktır n * n.

Expression     | Value                | Explanation
a              | a                    | point to array of int elements
a[n]           | a + n*sizeof(int)    | refer to n-th element in array of int elements
-------------------------------------------------------------------------------------------------
&a             | a                    | point to array of (n int elements array)
(&a)[n]        | a + n*sizeof(int[n]) | refer to n-th element in array of (n int elements array)
-------------------------------------------------------------------------------------------------
sizeof(int[n]) | n * sizeof(int)      | int[n] is a type of n-int-element array

Böylece,

1. bir çeşit (&a)[n] isimli int[n]işaretçi
2. bir çeşit a isimli intişaretçi

Şimdi ifade (&a)[n]-abir işaretçi çıkarma yapar:

  (&a)[n]-a
= ((a + n*sizeof(int[n])) - a) / sizeof(int)
= (n * sizeof(int[n])) / sizeof(int)
= (n * n * sizeof(int)) / sizeof(int)
= n * n