Jawaban:
Dua ekspresi berikut ini setara:
a->b
(*a).b
(tunduk pada kelebihan beban operator, seperti yang disebutkan Konrad, tapi itu tidak biasa).
a[0].b
sebagai gantinya (*a).b
. Tapi itu tidak akan terstruktur dengan baik.
a->b
umumnya merupakan sinonim untuk (*a).b
. Tanda kurung di sini diperlukan karena kekuatan pengikatan operator *
dan .
: *a.b
tidak akan berfungsi karena .
pengikatan lebih kuat dan dieksekusi terlebih dahulu. Jadi ini setara dengan *(a.b)
.
Waspadalah terhadap overloading, meskipun: Karena keduanya ->
dan *
bisa jadi overload, artinya bisa berbeda secara drastis.
binding strength
maksudmu operator didahulukan? jika tidak apa perbedaan antara keduanya?
Bahasa C ++ - mendefinisikan operator panah ( ->
) sebagai sinonim untuk mendereferensi penunjuk dan kemudian menggunakan .
-operator pada alamat itu.
Sebagai contoh:
Jika Anda memiliki objek itu, anObject
dan pointer, aPointer
:
SomeClass anObject = new SomeClass();
SomeClass *aPointer = &anObject;
Untuk dapat menggunakan salah satu metode objek, Anda mendereferensi penunjuk dan melakukan panggilan metode pada alamat itu:
(*aPointer).method();
Yang bisa ditulis dengan operator panah:
aPointer->method();
Alasan utama keberadaan operator panah adalah bahwa itu mempersingkat pengetikan tugas yang sangat umum dan juga agak mudah untuk melupakan tanda kurung di sekitar dereferensi penunjuk. Jika Anda lupa tanda kurung.-Operator akan mengikat lebih kuat dari * -operator dan membuat contoh kita dieksekusi sebagai:
*(aPointer.method()); // Not our intention!
Beberapa dari jawaban lain juga menyebutkan bahwa operator C ++ bisa kelebihan beban dan itu tidak umum.
new SomeClass()
mengembalikan pointer ( SomeClass *
), bukan SomeClass
objek. Dan Anda mulai dengan mendeklarasikan anObject
dan aPointer
tetapi Anda menggunakan p
sesudahnya.
Dalam C ++ 0x, operator mendapatkan arti kedua, yang menunjukkan tipe kembalian dari sebuah fungsi atau ekspresi lambda
auto f() -> int; // "->" means "returns ..."
::
sebenarnya adalah operator, seperti .
atau ->
, dan disebut "operator resolusi cakupan" dalam standar.
->
digunakan saat mengakses data yang penunjuknya Anda miliki.
Misalnya, Anda bisa membuat pointer ptr ke variabel bertipe int intVar seperti ini:
int* prt = &intVar;
Anda kemudian dapat menggunakan fungsi, seperti foo, di atasnya hanya dengan mendereferensi penunjuk itu - untuk memanggil fungsi pada variabel yang ditunjuk penunjuk, bukan pada nilai numerik dari lokasi memori variabel itu:
(*ptr).foo();
Tanpa tanda kurung di sini, kompilator akan memahami hal ini *(ptr.foo())
karena prioritas operator bukan yang kita inginkan.
Ini sebenarnya sama saja dengan mengetik
ptr->foo();
Sebagai ->
dereferensi penunjuk itu, dan karenanya memanggil fungsi foo()
pada variabel yang ditunjuk penunjuk untuk kita.
Demikian pula, kita dapat menggunakan ->
untuk mengakses atau mengatur anggota kelas:
myClass* ptr = &myClassMember;
ptr->myClassVar = 2;
->
operator yang kelebihan beban untuk beberapa jenis iterator sehingga Anda harus menggunakannya*.
. Banyak perpustakaan mendefinisikannya secara tidak konsisten. Menjadi sangat menjengkelkan ketika Anda bekerja dengan template dan tidak tahu jenis tepatnya.