Saya telah menemukan fungsi yang menghitung kuadrat suatu bilangan:
int p(int n) {
int a[n]; //works on C99 and above
return (&a)[n] - a;
}
Ini mengembalikan nilai n2. Pertanyaannya adalah, bagaimana cara melakukan hal itu? Setelah sedikit pengujian, saya menemukan bahwa antara (&a)[k] dan (&a)[k+1] adalah sizeof(a)/sizeof(int). Mengapa demikian?
Jelas sekali sebuah hack... tapi cara mengkuadratkan suatu bilangan tanpa menggunakan operator * (ini adalah persyaratan kontes coding).
(&a)[n]
setara dengan penunjuk ke int di lokasi
(a + sizeof(a[n])*n)
dan dengan demikian keseluruhan ekspresinya adalah
(&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
(&a) sebagai penunjuk ke objek n*sizeof(int) ketika n tidak diketahui pada waktu kompilasi. C dulunya adalah bahasa sederhana...
- person Floris; 08.01.2015
* dalam kode. Anda dapat memutuskan apa maksudnya. Ini tantangan yang konyol.
- person Mark Lakata; 09.01.2015
* memiliki lebih dari satu arti dalam C. Anda harus menyatakan secara spesifik tentang operator perkalian. Sekilas saya mengira Anda sedang berbicara tentang operator tipuan tetapi mengerti ketika mengunjungi tautannya.
- person haccks; 09.01.2015
Untuk memahami peretasan ini, pertama-tama Anda perlu memahami perbedaan penunjuk, yaitu apa yang terjadi jika dua penunjuk yang menunjuk ke elemen array yang sama dikurangi?
Ketika satu pointer dikurangi dari yang lain, hasilnya adalah jarak (diukur dalam elemen array) antara pointer. Jadi, jika p menunjuk ke a[i] dan q menunjuk ke a[j], maka p - q sama dengan i - j.
Ketika dua pointer dikurangi, keduanya akan menunjuk ke elemen objek array yang sama, atau yang melewati elemen terakhir objek array; hasilnya adalah selisih subskrip kedua elemen array. [...].
Dengan kata lain, jika ekspresiPdanQmasing-masing menunjuk ke elemen ke-9_ dan ke-jdari objek array, ekspresi(P)-(Q)memiliki nilaii−jasalkan nilainya cocok dengan objek bertipeptrdiff_t.
Sekarang saya berharap Anda mengetahui konversi nama array menjadi pointer, a mengkonversi ke pointer ke elemen pertama array a. &a adalah alamat seluruh blok memori, yaitu alamat array a. Gambar di bawah akan membantu Anda memahami (baca jawaban ini untuk penjelasan detail):
Ini akan membantu Anda memahami mengapa a dan &a memiliki alamat yang sama dan bagaimana (&a)[i] merupakan alamat 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 n array yang masing-masing berisi n int elemen. Oleh karena itu, total elemen array adalah n*n = n2.
CATATAN:
Ketika dua pointer dikurangi, keduanya akan menunjuk ke elemen objek array yang sama, atau yang melewati elemen terakhir objek array; hasilnya adalah selisih subskrip kedua elemen array. Ukuran hasilnya ditentukan oleh implementasi, dan tipenya (tipe bilangan bulat bertanda) adalah
ptrdiff_tyang ditentukan dalam header<stddef.h>. Jika hasilnya tidak dapat direpresentasikan dalam objek bertipe tersebut, perilakunya tidak terdefinisi.
Karena (&a)[n] tidak menunjuk ke elemen objek array yang sama atau yang melewati elemen terakhir objek array, (&a)[n] - a akan memunculkan perilaku tidak terdefinisi.
Perhatikan juga bahwa, lebih baik mengubah tipe pengembalian fungsi p menjadi ptrdiff_t.
&a[k] adalah alamat elemen ke k dari array a. Ini adalah (&a)[k] yang akan selalu dianggap sebagai alamat array elemen k. Jadi, elemen pertama berada pada posisi a (atau &a), elemen kedua berada pada posisi a + (jumlah elemen array a yaitu n)*(ukuran elemen array) dan seterusnya. Dan perhatikan bahwa, memori untuk array dengan panjang variabel dialokasikan di stack, bukan di heap.
- person haccks; 08.01.2015
(&a)[n]-(&a)[0] merupakan cara yang benar untuk melakukan ini?
- person Floris; 08.01.2015
(&a)[n] melanggar aturan standar yang mengatakan: keduanya harus menunjuk ke elemen objek array yang sama, atau yang melewati elemen terakhir objek array. Anda dapat melakukan ini dengan cara yang benar dengan mengubah isi fungsi menjadi return sizeof (char [n][n]); seperti yang disarankan di komentar ini.
- person haccks; 08.01.2015
a[n-1]. a[n] melewati elemen terakhir array. (&a)[1] adalah penunjuk untuk melewati elemen terakhir (array n int) dari array.
- person haccks; 14.01.2015
a adalah larik (variabel) dari n int.
&a adalah penunjuk ke array (variabel) n int.
(&a)[1] adalah penunjuk int satu int melewati elemen array terakhir. Pointer ini adalah n int elemen setelah &a[0].
(&a)[2] adalah penunjuk int satu int yang melewati elemen larik terakhir dari dua larik. Pointer ini adalah 2 * n int elemen setelah &a[0].
(&a)[n] adalah penunjuk int satu int yang melewati elemen larik terakhir dari larik n. Pointer ini adalah n * n int elemen setelah &a[0]. Kurangi saja &a[0] atau a dan Anda mendapatkan n.
Tentu saja ini adalah perilaku yang secara teknis tidak terdefinisi meskipun ini berfungsi di mesin Anda karena (&a)[n] tidak menunjuk ke dalam array atau melewati elemen array terakhir (seperti yang disyaratkan oleh aturan C aritmatika pointer).
[n] mendeklarasikan array dan array didekomposisi menjadi pointer. Tiga hal yang berguna secara terpisah dengan konsekuensi ini.
- person Tommy; 08.01.2015
(&a)[n] bertipe int[n], dan yang dinyatakan sebagai int* karena array dinyatakan sebagai alamat elemen pertamanya, jika deskripsinya tidak jelas.
- person WhozCraig; 08.01.2015
Jika Anda memiliki dua pointer yang menunjuk ke dua elemen dari array yang sama maka perbedaannya akan menghasilkan jumlah elemen di antara pointer tersebut. 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 a bertipe int * dan menunjuk ke elemen pertamanya.
Ekspresi &a memiliki tipe int ( * )[n] dan menunjuk ke baris pertama dari gambar array dua dimensi. Nilainya cocok dengan nilai a meskipun tipenya berbeda.
( &a )[n]
adalah elemen ke-n dari array dua dimensi yang dicitrakan ini dan memiliki tipe int[n] Yaitu baris ke-n dari array yang dicitrakan. Dalam ekspresi (&a)[n] - a diubah ke alamat elemen pertamanya dan bertipe `int *.
Jadi antara (&a)[n] dan a ada n baris n elemen. Jadi selisihnya akan sama dengan 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
Dengan demikian,
(&a)[n] adalah int[n] penunjuka adalah int penunjukSekarang ekspresi (&a)[n]-a melakukan pengurangan pointer:
(&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
int p(n)? Apakah itu bisa dikompilasi? - person barak manos schedule 08.01.2015gcc. - person lurker schedule 08.01.2015int q(int n) { return sizeof (char [n][n]); }- person ouah schedule 08.01.2015sizeofuntuk menyimpan karakter. Yang lainnya: ini adalah kode yang sengaja dikaburkan, perilakunya tidak terdefinisi, jawaban @ouah benar. - person ecatmur schedule 08.01.2015O(n^2)untuk menghitungn^2- person Khaled.K schedule 14.01.2015