Seperti yang ditunjukkan Joel dalam Stack Overflow podcast # 34 , dalam Bahasa Pemrograman C (alias: K & R), disebutkan properti array ini di C:a[5] == 5[a]

Joel mengatakan bahwa itu karena pointer aritmatika tetapi saya masih tidak mengerti. Kenapa begitua[5] == 5[a] ?

Standar C mendefinisikan []operator sebagai berikut:

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

Karena itu a[5]akan dievaluasi untuk:

*(a + 5)

dan 5[a]akan mengevaluasi untuk:

*(5 + a)

aadalah pointer ke elemen pertama array. a[5]adalah nilai yang 5 elemen lebih jauh dari a, yang sama dengan *(a + 5), dan dari matematika sekolah dasar kita tahu mereka sama (penambahan bersifat komutatif ).

Karena akses array didefinisikan dalam hal pointer. a[i]didefinisikan sebagai mean *(a + i), yang komutatif.

Saya pikir ada sesuatu yang terlewatkan oleh jawaban lain.

Ya, p[i]secara definisi setara dengan *(p+i), yang (karena penambahan komutatif) setara dengan *(i+p), yang (sekali lagi, menurut definisi []operator) setara dengan i[p].

(Dan dalam array[i], nama array secara implisit dikonversi menjadi pointer ke elemen pertama array.)

Tetapi komutatifitas penambahan tidak begitu jelas dalam kasus ini.

Ketika kedua operan adalah dari jenis yang sama, atau bahkan dari jenis numerik yang berbeda yang dipromosikan ke jenis umum, komutatif masuk akal: x + y == y + x.

Tetapi dalam kasus ini kita berbicara secara spesifik tentang pointer aritmatika, di mana satu operan adalah pointer dan yang lainnya adalah integer. (Integer + integer adalah operasi yang berbeda, dan pointer + pointer tidak masuk akal.)

Deskripsi standar C +operator ( N1570 6.5.6) mengatakan:

Sebagai tambahan, kedua operan harus memiliki tipe aritmatika, atau satu operan harus menjadi pointer ke tipe objek lengkap dan yang lainnya harus memiliki tipe integer.

Itu bisa dengan mudah dikatakan:

Sebagai tambahan, kedua operan harus memiliki tipe aritmatika, atau operan kiri harus menjadi pointer ke tipe objek lengkap dan operan kanan harus memiliki tipe integer.

dalam hal ini keduanya i + pdan i[p]akan ilegal.

Dalam istilah C ++, kami benar-benar memiliki dua set +operator kelebihan beban , yang secara longgar dapat digambarkan sebagai:

pointer operator+(pointer p, integer i);

dan

pointer operator+(integer i, pointer p);

dimana hanya yang pertama yang benar-benar diperlukan.

Jadi mengapa demikian?

C ++ mewarisi definisi ini dari C, yang mendapatkannya dari B (komutatifitas pengindeksan array secara eksplisit disebutkan dalam referensi pengguna 1972 ke B ), yang mendapatkannya dari BCPL (manual bertanggal 1967), yang mungkin mendapatkannya dari gen bahasa sebelumnya (CPL? Algol?).

Jadi gagasan bahwa pengindeksan array didefinisikan dalam hal penambahan, dan penambahan itu, bahkan penunjuk dan bilangan bulat, adalah komutatif, kembali beberapa dekade, ke bahasa leluhur C.

Bahasa-bahasa itu diketik kurang kuat daripada C modern. Secara khusus, perbedaan antara pointer dan integer sering diabaikan. (Pemrogram C awal kadang-kadang menggunakan pointer sebagai bilangan bulat yang tidak ditandatangani, sebelum unsignedkata kunci ditambahkan ke bahasa.) Jadi ide membuat penambahan non-komutatif karena operan dari tipe yang berbeda mungkin tidak akan terjadi pada perancang bahasa tersebut. Jika pengguna ingin menambahkan dua "hal", apakah "hal" itu adalah bilangan bulat, pointer, atau sesuatu yang lain, itu tidak sesuai dengan bahasa untuk mencegahnya.

Dan selama bertahun-tahun, setiap perubahan pada aturan itu akan merusak kode yang ada (meskipun standar ANSI C 1989 mungkin merupakan peluang yang baik).

Mengubah C dan / atau C ++ untuk mengharuskan meletakkan pointer di sebelah kiri dan integer di sebelah kanan dapat merusak beberapa kode yang ada, tetapi tidak akan ada kehilangan kekuatan ekspresif nyata.

Jadi sekarang kita memiliki arr[3]dan 3[arr]memaknai hal yang persis sama, meskipun bentuk yang terakhir seharusnya tidak pernah muncul di luar IOCCC .

Dan tentu saja

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

Alasan utama untuk ini adalah bahwa kembali di tahun 70-an ketika C dirancang, komputer tidak memiliki banyak memori (64KB banyak), sehingga kompiler C tidak melakukan banyak pemeriksaan sintaks. Karenanya " X[Y]" diterjemahkan agak membabi buta ke " *(X+Y)"

Ini juga menjelaskan sintaksis " +=" dan " ++". Segala sesuatu dalam bentuk " A = B + C" memiliki bentuk kompilasi yang sama. Tetapi, jika B adalah objek yang sama dengan A, maka optimasi tingkat perakitan tersedia. Tetapi kompiler tidak cukup pintar untuk mengenalinya, jadi pengembang harus ( A += C). Demikian pula, jika Cada 1, optimasi tingkat perakitan berbeda tersedia, dan sekali lagi pengembang harus membuatnya eksplisit, karena kompiler tidak mengenalinya. (Kompiler yang lebih baru melakukannya, jadi sintaksis itu sebagian besar tidak perlu hari ini)

Satu hal yang sepertinya tidak ada yang menyebutkan tentang masalah Dinah dengan sizeof:

Anda hanya bisa menambahkan integer ke sebuah pointer, Anda tidak bisa menambahkan dua pointer bersamaan. Dengan begitu ketika menambahkan pointer ke integer, atau integer ke pointer, kompiler selalu tahu bit mana yang memiliki ukuran yang perlu diperhitungkan.

Untuk menjawab pertanyaan secara harfiah. Tidak selalu benar demikianx == x

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

cetakan

false

Saya baru tahu sintaks jelek ini bisa "berguna", atau setidaknya sangat menyenangkan untuk dimainkan ketika Anda ingin berurusan dengan array indeks yang merujuk ke posisi ke dalam array yang sama. Itu dapat menggantikan tanda kurung bersarang dan membuat kode lebih mudah dibaca!

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)

}

Tentu saja, saya cukup yakin bahwa tidak ada kasus penggunaan untuk itu dalam kode nyata, tetapi saya tetap merasa menarik :)

Pertanyaan / jawaban yang bagus.

Hanya ingin menunjukkan bahwa pointer C dan array tidak sama , meskipun dalam hal ini perbedaannya tidak penting.

Pertimbangkan deklarasi berikut:

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

Di a.out, simbol aberada di alamat yang merupakan awal array, dan simbol pberada di alamat tempat pointer disimpan, dan nilai pointer di lokasi memori itu adalah awal dari array.

Untuk petunjuk dalam C, kami punya

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

dan juga

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

Karena itu memang benar demikian a[5] == 5[a].

Bukan jawaban, tapi hanya makanan untuk dipikirkan. Jika kelas memiliki operator indeks / subskrip kelebihan, ekspresi 0[x]tidak akan berfungsi:

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

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

Karena kami tidak memiliki akses ke kelas int , ini tidak dapat dilakukan:

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

Ini memiliki penjelasan yang sangat baik dalam A TUTORIAL ON POINTERS DAN ARRAYS IN C oleh Ted Jensen.

Ted Jensen menjelaskannya sebagai:

Bahkan, ini benar, yaitu di mana pun orang menulis a[i]itu dapat diganti *(a + i) tanpa masalah. Bahkan, kompiler akan membuat kode yang sama dalam kedua kasus. Jadi kita melihat bahwa pointer aritmatika adalah hal yang sama dengan pengindeksan array. Entah sintaks menghasilkan hasil yang sama.

Ini BUKAN mengatakan bahwa pointer dan array adalah hal yang sama, mereka tidak. Kami hanya mengatakan bahwa untuk mengidentifikasi elemen tertentu dari array kami memiliki pilihan dua sintaks, satu menggunakan indeks array dan yang lainnya menggunakan aritmatika pointer, yang menghasilkan hasil yang identik.

Sekarang, melihat ekspresi terakhir ini, bagian dari itu .. (a + i), adalah tambahan sederhana menggunakan operator + dan aturan C menyatakan bahwa ekspresi seperti itu komutatif. Artinya (a + i) identik dengan (i + a). Jadi kita bisa menulis *(i + a)semudah itu *(a + i). Tapi *(i + a)bisa saja berasal i[a]! Dari semua ini muncul kebenaran yang aneh bahwa jika:

char a[20];

penulisan

a[3] = 'x';

sama dengan menulis

3[a] = 'x';

Saya tahu pertanyaannya dijawab, tetapi saya tidak tahan untuk tidak membagikan penjelasan ini.

Saya ingat desain Principles of Compiler, Mari kita asumsikan aadalah intarray dan ukurannya intadalah 2 byte, & Base address aadalah 1000.

Bagaimana cara a[5]kerjanya ->

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

Begitu,

Demikian pula ketika kode c dipecah menjadi kode 3-alamat, 5[a]akan menjadi ->

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

Jadi pada dasarnya kedua pernyataan menunjuk ke lokasi yang sama di memori dan karenanya a[5] = 5[a],.

Penjelasan ini juga merupakan alasan mengapa indeks negatif dalam array bekerja di C.

yaitu jika saya mengaksesnya a[-5]akan memberi saya

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

Ini akan mengembalikan saya objek di lokasi 990.

Dalam C array , arr[3]dan 3[arr]adalah sama, dan notasi pointer mereka setara yang *(arr + 3)ke *(3 + arr). Tetapi sebaliknya [arr]3atau [3]arrtidak benar dan akan menghasilkan kesalahan sintaksis, karena (arr + 3)*dan (3 + arr)*bukan ekspresi yang valid. Alasannya adalah operator dereference harus ditempatkan sebelum alamat yang dihasilkan oleh ekspresi, bukan setelah alamat.

dalam c compiler

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

ada berbagai cara untuk merujuk ke elemen dalam array! (BUKAN SEMUA WEIRD)

Sedikit sejarah sekarang. Di antara bahasa-bahasa lain, BCPL memiliki pengaruh yang cukup besar pada perkembangan awal C. Jika Anda mendeklarasikan array di BCPL dengan sesuatu seperti:

let V = vec 10

yang sebenarnya mengalokasikan 11 kata memori, bukan 10. Biasanya V adalah yang pertama, dan berisi alamat dari kata berikut segera. Jadi tidak seperti C, penamaan V pergi ke lokasi itu dan mengambil alamat elemen zeroeth dari array. Oleh karena itu array tidak langsung dalam BCPL, dinyatakan sebagai

let J = V!5

benar-benar harus melakukan J = !(V + 5)(menggunakan sintaks BCPL) karena itu perlu untuk mengambil V untuk mendapatkan alamat basis dari array. Jadi V!5dan 5!Vitu identik. Sebagai pengamatan anekdotal, WAFL (Warwick Functional Language) ditulis dalam BCPL, dan yang terbaik dari ingatan saya cenderung menggunakan sintaks yang terakhir daripada yang sebelumnya untuk mengakses node yang digunakan sebagai penyimpanan data. Memang ini dari suatu tempat antara 35 dan 40 tahun yang lalu, jadi ingatanku agak berkarat. :)

Inovasi mengeluarkan kata penyimpanan ekstra dan meminta kompiler memasukkan alamat dasar array ketika dinamai datang kemudian. Menurut makalah sejarah C ini terjadi pada sekitar waktu struktur ditambahkan ke C.

Perhatikan bahwa !dalam BCPL adalah operator awalan unary dan operator infiks biner, dalam kedua kasus melakukan tipuan. Hanya saja bentuk biner termasuk penambahan dua operan sebelum melakukan tipuan. Mengingat sifat berorientasi kata BCPL (dan B) ini sebenarnya membuat banyak akal. Pembatasan "pointer dan integer" dibuat perlu di C ketika memperoleh tipe data, dan sizeofmenjadi sesuatu.

Ya, ini adalah fitur yang hanya mungkin karena dukungan bahasa.

Compiler mengartikan a[i]sebagai *(a+i)dan ekspresi 5[a]dievaluasi untuk *(5+a). Karena penambahan bersifat komutatif, ternyata keduanya sama. Karenanya ekspresi dievaluasi menjadi true.

Dalam C

 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

Pointer adalah "variabel"

nama array adalah "mnemonic" atau "sinonim"

p++;valid tetapi a++tidak valid

a[2] sama dengan 2 [a] karena operasi internal pada keduanya adalah

"Aritmatika Pointer" dihitung secara internal sebagai

*(a+3) sama dengan *(3+a)

jenis penunjuk

1) pointer ke data

int *ptr;

2) const pointer ke data

int const *ptr;

3) pointer pointer ke data const

int const *const ptr;

dan array adalah tipe (2) dari daftar kami.
Ketika Anda mendefinisikan sebuah array pada suatu waktu, satu alamat diinisialisasi dalam pointer tersebut.
Seperti yang kita tahu bahwa kita tidak dapat mengubah atau memodifikasi nilai const dalam program kita karena itu melemparkan ERROR saat dikompilasi. waktu

Perbedaan utama yang saya temukan adalah ...

Kami dapat menginisialisasi ulang pointer dengan alamat tetapi tidak dengan case yang sama dengan array.

======
dan kembali ke pertanyaan Anda ...
a[5]tidak lain adalah *(a + 5)
Anda dapat memahami dengan mudah dengan
a - berisi alamat (orang menyebutnya sebagai alamat dasar) seperti jenis penunjuk (2) dalam daftar kami
[]- operator itu dapat diganti dengan pointer *.

jadi akhirnya ...

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