Tidak dapat memahami cara menghitung kuadrat dari sebuah angka

Saya telah menemukan fungsi yang menghitung kuadrat angka:

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

Ini mengembalikan nilai n ² . Pertanyaannya adalah, bagaimana cara melakukannya? Setelah sedikit pengujian, saya menemukan bahwa antara (&a)[k]dan (&a)[k+1]is sizeof(a)/ sizeof(int). Mengapa demikian?

Jelas hack ... tapi cara mengkuadratkan angka tanpa menggunakan *operator (ini adalah persyaratan kontes pengkodean).

(&a)[n] 

setara dengan penunjuk ke intdi lokasi

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

dan dengan demikian keseluruhan ekspresi itu

  (&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

Untuk memahami peretasan ini, pertama-tama Anda perlu memahami perbedaan penunjuk, yaitu, apa yang terjadi jika dua penunjuk yang menunjuk ke elemen larik yang sama dikurangi?

Ketika satu pointer dikurangkan dari pointer lainnya, hasilnya adalah jarak (diukur dalam elemen array) antara pointer. Jadi, jika pmenunjuk ke a[i]dan qmenunjuk ke a[j], maka p - qsama dengani - j .

C11: 6.5.6 Operator aditif (p9):

Ketika dua penunjuk dikurangi , keduanya harus menunjuk ke elemen dari objek larik yang sama, atau satu melewati elemen terakhir dari objek larik; hasilnya adalah perbedaan subskrip dari dua elemen array . [...].
Dengan kata lain, jika ekspresi Pdan Qmenunjuk ke, masing-masing, elemen i-th dan j-th dari sebuah objek array, ekspresi tersebut (P)-(Q)memiliki nilaii−j asalkan nilainya sesuai dengan sebuah objek bertipe ptrdiff_t.

Sekarang saya mengharapkan bahwa Anda mengetahui konversi nama array ke pointer, amengubahnya menjadi pointer ke elemen pertama dari array a. &aadalah alamat seluruh blok memori, yaitu alamat array a. Gambar di bawah ini akan membantu Anda untuk memahami ( _{baca jawaban ini untuk penjelasan rinci} ):

Ini akan membantu Anda untuk memahami mengapa adan &amemiliki alamat yang sama dan bagaimana (&a)[i]alamat dari array ^ke- i (dengan ukuran yang sama dengan a).

Jadi, pernyataannya

return (&a)[n] - a; 

setara dengan

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

dan perbedaan ini akan memberikan jumlah elemen antara pointer (&a)[n]dan (&a)[0], yang merupakan narray setiap n intelemen. Oleh karena itu, total elemen array adalah n*n= n² .

CATATAN:

C11: 6.5.6 Operator aditif (p9):

Ketika dua penunjuk dikurangi, keduanya harus menunjuk ke elemen dari objek larik yang sama, atau satu melewati elemen terakhir dari objek larik ; hasilnya adalah perbedaan subskrip dari dua elemen array. Ukuran hasil ditentukan oleh implementasi , dan tipenya (tipe integer bertanda) ptrdiff_tditentukan di <stddef.h>header. Jika hasilnya tidak dapat direpresentasikan dalam objek jenis itu, perilaku tidak ditentukan.

Karena (&a)[n]tidak menunjuk ke elemen dari objek array yang sama atau melewati elemen terakhir dari objek array, tidak (&a)[n] - aakan memunculkan perilaku tidak terdefinisi .

Perhatikan juga bahwa, lebih baik untuk mengubah jenis fungsi yang dikembalikan pmenjadi ptrdiff_t.

aadalah larik (variabel) dari n int.

&aadalah penunjuk ke larik (variabel) dari n int.

(&a)[1]adalah penunjuk intsalah satu intelemen larik terakhir. Pointer ini adalah n intelemen setelahnya &a[0].

(&a)[2]adalah penunjuk intsalah satu intelemen array terakhir dari dua array. Pointer ini adalah 2 * n intelemen setelahnya &a[0].

(&a)[n]adalah penunjuk intsalah satu intelemen array terakhir dari narray. Pointer ini adalah n * n intelemen setelahnya &a[0]. Kurangi saja &a[0]atau adan Anda sudah memilikinya n.

Tentu saja ini secara teknis adalah perilaku yang tidak terdefinisi bahkan jika berfungsi pada mesin Anda karena (&a)[n]tidak menunjuk ke dalam larik atau melewati elemen larik terakhir (seperti yang disyaratkan oleh aturan C aritmatika penunjuk).

Jika Anda memiliki dua pointer yang mengarah ke dua elemen dari array yang sama maka perbedaannya akan menghasilkan jumlah elemen di antara pointer ini. Misalnya cuplikan kode ini akan menghasilkan 2.

int a[10];

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

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

Sekarang mari pertimbangkan ekspresi

(&a)[n] - a;

Dalam ekspresi ini amemiliki tipe int *dan menunjuk ke elemen pertamanya.

Ekspresi &amemiliki tipe int ( * )[n]dan poin ke baris pertama dari larik dua dimensi yang dicitrakan. Nilainya sesuai dengan nilai ameskipun jenisnya berbeda.

( &a )[n]

adalah elemen ke-n dari larik dua dimensi yang dicitrakan dan memiliki tipe. int[n]Itu adalah baris ke-n dari larik yang dicitrakan. Dalam ekspresi (&a)[n] - aitu dikonversi ke alamat elemen pertama dan memiliki tipe `int *.

Jadi di antara (&a)[n]dan aada n baris n elemen. Jadi perbedaannya akan sama 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

Jadi,

1. jenisnya (&a)[n]adalah int[n]penunjuk
2. jenisnya aadalah intpenunjuk

Sekarang ekspresi (&a)[n]-amelakukan substraksi penunjuk:

  (&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