Aku selalu mengacaukan bagaimana menggunakan const int*, const int * constdan int const *benar. Apakah ada seperangkat aturan yang mendefinisikan apa yang bisa dan tidak bisa Anda lakukan?

Saya ingin mengetahui semua hal yang harus dan tidak boleh dilakukan dalam hal penugasan, melewati fungsi, dll.

Baca terbalik (didorong oleh Searah Jarum Jam / Spiral ):

• int* - pointer ke int
• int const * - pointer ke const int
• int * const - const pointer ke int
• int const * const - const pointer ke const int

Sekarang yang pertama constbisa berada di kedua sisi tipe jadi:

• const int * == int const *
• const int * const == int const * const

Jika Anda ingin menjadi sangat gila, Anda dapat melakukan hal-hal seperti ini:

• int ** - pointer ke pointer ke int
• int ** const - pointer const ke pointer ke int
• int * const * - pointer ke pointer const ke int
• int const ** - pointer ke pointer ke const int
• int * const * const - pointer const ke pointer const ke int
• ...

Dan untuk memastikan kami jelas tentang arti dari const:

int a = 5, b = 10, c = 15;

const int* foo;     // pointer to constant int.
foo = &a;           // assignment to where foo points to.

/* dummy statement*/
*foo = 6;           // the value of a can´t get changed through the pointer.

foo = &b;           // the pointer foo can be changed.



int *const bar = &c;  // constant pointer to int 
                      // note, you actually need to set the pointer 
                      // here because you can't change it later ;)

*bar = 16;            // the value of c can be changed through the pointer.    

/* dummy statement*/
bar = &a;             // not possible because bar is a constant pointer.           

fooadalah pointer variabel ke integer konstan. Ini memungkinkan Anda mengubah apa yang Anda tuju tetapi bukan nilai yang Anda tuju. Paling sering ini terlihat dengan string C-style di mana Anda memiliki pointer ke a const char. Anda dapat mengubah string mana yang Anda tuju tetapi Anda tidak dapat mengubah konten string ini. Ini penting ketika string itu sendiri berada di segmen data dari suatu program dan tidak boleh diubah.

baradalah pointer konstan atau tetap ke nilai yang dapat diubah. Ini seperti referensi tanpa tambahan gula sintaksis. Karena fakta ini, biasanya Anda akan menggunakan referensi di mana Anda akan menggunakan T* constpointer kecuali Anda perlu mengizinkan NULLpointer.

Bagi mereka yang tidak tahu tentang Searah Jarum Jam / Spiral: Mulai dari nama variabel, gerakkan dengan jarum jam (dalam hal ini, pindah ke belakang) ke pointer atau jenis berikutnya . Ulangi sampai ekspresi berakhir.

Ini demo:

Saya pikir semuanya sudah dijawab di sini, tetapi saya hanya ingin menambahkan bahwa Anda harus berhati-hati typedef! Mereka BUKAN hanya penggantian teks.

Sebagai contoh:

typedef char *ASTRING;
const ASTRING astring;

Jenisnya astringadalah char * consttidak const char *. Ini adalah salah satu alasan saya selalu cenderung untuk menempatkan consthak jenis, dan tidak pernah di awal.

Seperti hampir semua orang tunjukkan:

Apa bedanya const X* p, X* const pdan const X* const p?

Anda harus membaca deklarasi pointer dari kanan ke kiri.

• const X* p berarti "p menunjuk ke X yang merupakan const": objek X tidak dapat diubah melalui p.

• X* const p berarti "p adalah pointer const ke X yang non-const": Anda tidak dapat mengubah pointer p itu sendiri, tetapi Anda dapat mengubah objek X melalui p.

• const X* const p berarti "p adalah pointer const ke X yang merupakan const": Anda tidak dapat mengubah pointer p itu sendiri, Anda juga tidak dapat mengubah objek X melalui p.

1. Referensi konstan:

   Referensi ke variabel (di sini int), yang konstan. Kami melewatkan variabel sebagai referensi terutama, karena ukuran referensi lebih kecil daripada nilai sebenarnya, tetapi ada efek samping dan itu karena itu seperti alias ke variabel aktual. Kami mungkin secara tidak sengaja mengubah variabel utama melalui akses penuh kami ke alias, jadi kami membuatnya konstan untuk mencegah efek samping ini.

   int var0 = 0;
   const int &ptr1 = var0;
   ptr1 = 8; // Error
   var0 = 6; // OK

2. Pointer konstan

   Setelah pointer konstan menunjuk ke suatu variabel maka itu tidak dapat menunjuk ke variabel lain.

   int var1 = 1;
   int var2 = 0;
   
   int *const ptr2 = &var1;
   ptr2 = &var2; // Error

3. Pointer ke konstan

   Sebuah penunjuk yang melaluinya orang tidak dapat mengubah nilai suatu variabel yang dikenal sebagai penunjuk menjadi konstan.

   int const * ptr3 = &var2;
   *ptr3 = 4; // Error

4. Pointer konstan ke konstanta

   Pointer konstan ke konstanta adalah pointer yang tidak dapat mengubah alamat yang ditunjuknya dan juga tidak dapat mengubah nilai yang disimpan di alamat itu.

   int var3 = 0;
   int var4 = 0;
   const int * const ptr4 = &var3;
   *ptr4 = 1;     // Error
    ptr4 = &var4; // Error

Aturan umum adalah bahwa constkata kunci berlaku untuk apa yang mendahuluinya segera. Pengecualian, permulaan constberlaku untuk hal-hal berikut.

• const int*sama dengan int const*dan berarti "pointer ke int konstan" .
• const int* constsama dengan int const* constdan berarti "pointer konstan ke int konstan" .

Sunting: Untuk Dos dan Larangan, jika jawaban ini tidak cukup, dapatkah Anda lebih tepat tentang apa yang Anda inginkan?

Pertanyaan ini menunjukkan dengan tepat mengapa saya suka melakukan hal-hal seperti yang saya sebutkan dalam pertanyaan saya adalah const setelah jenis id dapat diterima?

Singkatnya, saya menemukan cara termudah untuk mengingat aturannya adalah "const" mengejar hal yang berlaku. Jadi dalam pertanyaan Anda, "int const *" berarti int adalah konstan, sedangkan "int * const" akan berarti bahwa pointernya konstan.

Jika seseorang memutuskan untuk meletakkannya di bagian paling depan (misalnya: "const int *"), sebagai pengecualian khusus dalam kasus itu berlaku untuk hal setelah itu.

Banyak orang suka menggunakan pengecualian khusus itu karena mereka pikir itu terlihat lebih bagus. Saya tidak menyukainya, karena itu pengecualian, dan karenanya membingungkan banyak hal.

Penggunaan Sederhana const.

Penggunaan paling sederhana adalah mendeklarasikan konstanta bernama. Untuk melakukan ini, satu menyatakan konstanta seolah-olah itu variabel tetapi tambahkanconst sebelumnya. Kita harus segera menginisialisasi di konstruktor karena, tentu saja, kita tidak dapat menetapkan nilai nanti karena itu akan mengubahnya. Sebagai contoh:

const int Constant1=96; 

akan membuat konstanta integer, tidak terbayangkan dipanggil Constant1 , dengan nilai 96.

Konstanta semacam itu berguna untuk parameter yang digunakan dalam program tetapi tidak perlu diubah setelah program dikompilasi. Ini memiliki keuntungan bagi programmer daripada preprocessor C#define perintah dalam hal itu dipahami & digunakan oleh kompiler itu sendiri, tidak hanya diganti ke dalam teks program oleh preprocessor sebelum mencapai kompilator utama, sehingga pesan kesalahan jauh lebih bermanfaat.

Ini juga berfungsi dengan pointer tetapi kita harus berhati-hati di mana const menentukan apakah pointer atau apa yang menunjuk adalah konstan atau keduanya. Sebagai contoh:

const int * Constant2 

menyatakan bahwa Constant2pointer variabel ke integer konstan dan:

int const * Constant2

adalah sintaks alternatif yang melakukan hal yang sama, sedangkan

int * const Constant3

menyatakan bahwa Constant3adalah pointer konstan ke variabel integer dan

int const * const Constant4

menyatakan itu Constant4 adalah pointer konstan ke integer konstan. Pada dasarnya 'const' berlaku untuk apa pun yang ada di sebelah kirinya (selain jika tidak ada di sana dalam hal ini berlaku untuk apa pun yang merupakan hak langsungnya).

ref: http://duramecho.com/ComputerInformation/WhyHowCppConst.html

Saya memiliki keraguan yang sama seperti Anda sampai saya menemukan buku ini oleh C ++ Guru Scott Meyers. Rujuk Item ketiga dalam buku ini di mana ia berbicara secara rinci tentang penggunaan const.

Ikuti saja saran ini

1. Jika kata constmuncul di sebelah kiri tanda bintang, yang ditunjukkan adalah konstan
2. Jika kata constmuncul di sebelah kanan tanda bintang, penunjuk itu sendiri konstan
3. Jika constmuncul di kedua sisi, keduanya konstan

Sederhana tapi rumit. Harap dicatat bahwa kami dapat menukar constkualifikasi dengan jenis data ( int, char,float , dll).

Mari kita lihat contoh di bawah ini.

const int *p==> *pread-only [ padalah pointer ke integer konstan]

int const *p==> *pread-only [ padalah pointer ke integer konstan]

int *p const==> Pernyataan Salah . Compiler melempar kesalahan sintaksis.

int *const p==> pread-only [ padalah pointer konstan ke integer]. Karena pointer di psini hanya baca, deklarasi dan definisi harus berada di tempat yang sama.

const int *p const ==> Pernyataan Salah . Compiler melempar kesalahan sintaksis.

const int const *p ==> *phanya-baca

const int *const p1 ==> *pdan phanya-baca [ padalah pointer konstan ke integer konstan]. Karena pointer di psini hanya baca, deklarasi dan definisi harus berada di tempat yang sama.

int const *p const ==> Pernyataan Salah . Compiler melempar kesalahan sintaksis.

int const int *p ==> Pernyataan Salah . Compiler melempar kesalahan sintaksis.

int const const *p ==> *phanya-baca dan setara denganint const *p

int const *const p ==> *pdan phanya-baca [ padalah pointer konstan ke integer konstan]. Karena pointer di psini hanya baca, deklarasi dan definisi harus berada di tempat yang sama.

Ada banyak titik halus lainnya seputar kebenaran const di C ++. Saya kira pertanyaan di sini hanyalah tentang C, tapi saya akan memberikan beberapa contoh terkait karena tag tersebut adalah C ++:

• Anda sering memberikan argumen besar seperti string TYPE const &yang mencegah objek dari modifikasi atau disalin. Contoh:

  TYPE& TYPE::operator=(const TYPE &rhs) { ... return *this; }

  Tetapi TYPE & consttidak ada artinya karena referensi selalu const.

• Anda harus selalu memberi label metode kelas yang tidak mengubah kelas sebagai const, jika tidak, Anda tidak dapat memanggil metode dari TYPE const &referensi. Contoh:

  bool TYPE::operator==(const TYPE &rhs) const { ... }

• Ada situasi umum di mana nilai pengembalian dan metode harus berupa const. Contoh:

  const TYPE TYPE::operator+(const TYPE &rhs) const { ... }

  Bahkan, metode const tidak boleh mengembalikan data kelas internal sebagai referensi-ke-non-const.

• Akibatnya, kita harus sering membuat kedua metode const dan non-const menggunakan overloading const. Misalnya, jika Anda mendefinisikan T const& operator[] (unsigned i) const;, maka Anda mungkin juga menginginkan versi non-const yang diberikan oleh:

  inline T& operator[] (unsigned i) { return const_cast<char&>( static_cast<const TYPE&>(*this)[](i) ); }

Afaik, tidak ada fungsi const di C, fungsi non-anggota tidak dapat dengan sendirinya menjadi const di C ++, metode const mungkin memiliki efek samping, dan kompiler tidak dapat menggunakan fungsi const untuk menghindari panggilan fungsi ganda. Bahkan, bahkan int const &referensi sederhana dapat menyaksikan nilai yang dirujuk diubah di tempat lain.

Sintaks deklarasi C dan C ++ telah berulang kali dideskripsikan sebagai percobaan yang gagal, oleh desainer asli.

Sebagai gantinya, beri nama tipe "pointer to Type"; Saya akan menyebutnya Ptr_:

template< class Type >
using Ptr_ = Type*;

Sekarang Ptr_<char>adalah pointer ke char.

Ptr_<const char>adalah penunjuk ke const char.

Dan const Ptr_<const char>adalah constpointer ke const char.

Sana.

Bagi saya, posisi constyaitu apakah muncul ke KIRI atau KANAN atau pada KIRI dan KANAN relatif terhadap *membantu saya mencari tahu arti sebenarnya.

1. A constke KIRI dari *menunjukkan bahwa objek yang ditunjuk oleh pointer adalah constobjek.

2. A consthingga HAK *menunjukkan bahwa pointer adalah constpointer.

Tabel berikut diambil dari Stanford CS106L Standard C ++ Programming Laboratory Reader Reader.

Ini sebagian besar membahas baris kedua: praktik terbaik, tugas, parameter fungsi dll.

Latihan umum. Cobalah untuk membuat segala constyang Anda bisa. Atau dengan kata lain, buat semuanya constuntuk memulai, dan kemudian hapus set minimumconst diperlukan untuk memungkinkan program berfungsi. Ini akan sangat membantu dalam mencapai pembenaran yang benar, dan akan membantu memastikan bahwa bug halus tidak diperkenalkan ketika orang mencoba dan menetapkan hal-hal yang seharusnya tidak mereka modifikasi.

Hindari const_cast <> seperti wabah. Ada satu atau dua kasus penggunaan yang sah untuk itu, tetapi mereka sangat sedikit dan jarang. Jika Anda mencoba mengubah constobjek, Anda akan melakukan jauh lebih baik untuk menemukan siapa pun yang menyatakannyaconst pada langkah pertama dan membicarakannya dengan mereka untuk mencapai konsensus tentang apa yang harus terjadi.

Yang mengarah ke tugas dengan sangat rapi. Anda dapat menetapkan ke dalam sesuatu hanya jika itu non-const. Jika Anda ingin menetapkan sesuatu yang const, lihat di atas. Ingatlah bahwa dalam deklarasi int const *foo;dan int * const bar;hal-hal yang berbedaconst - jawaban lain di sini telah membahas masalah itu dengan mengagumkan, jadi saya tidak akan membahasnya.

Parameter fungsi:

Lewati nilai: mis. void func(int param)Anda tidak peduli dengan satu atau lain cara di situs panggilan. Argumen dapat dibuat bahwa ada kasus penggunaan untuk mendeklarasikan fungsi sebagai void func(int const param)tetapi yang tidak berpengaruh pada pemanggil, hanya pada fungsi itu sendiri, dalam nilai apa pun yang dilewatkan tidak dapat diubah oleh fungsi selama panggilan.

Lulus dengan referensi: mis. void func(int &param)Sekarang itu membuat perbedaan. Seperti yang baru saja dinyatakan funcdiizinkan untuk berubah param, dan situs panggilan apa pun harus siap untuk menghadapi konsekuensinya. Mengubah deklarasi untuk void func(int const &param)mengubah kontrak, dan jaminan yang funcsekarang tidak dapat berubahparam , berarti apa yang disahkan adalah apa yang akan keluar. Seperti yang telah dicatat orang lain, ini sangat berguna untuk melewati benda besar yang tidak ingin Anda ubah dengan murah. Melewati referensi jauh lebih murah daripada melewatkan objek besar berdasarkan nilai.

Lewati dengan penunjuk: misalnya void func(int *param)dan void func(int const *param)Keduanya cukup identik dengan rekan referensi mereka, dengan peringatan bahwa fungsi yang dipanggil sekarang perlu diperiksa nullptrkecuali beberapa jaminan kontrak lainnya memastikan funcbahwa ia tidak akan pernah menerima nullptrin param.

Sepotong opini tentang topik itu. Membuktikan kebenaran dalam kasus seperti ini sangat sulit, terlalu mudah untuk membuat kesalahan. Jadi jangan mengambil risiko, dan selalu periksa parameter pointer untuk nullptr. Anda akan menyelamatkan diri dari rasa sakit dan penderitaan dan sulit menemukan serangga dalam jangka panjang. Dan untuk biaya pemeriksaan, ini sangat murah, dan dalam kasus-kasus di mana analisis statis yang dibangun dalam kompiler dapat mengelolanya, pengoptimal akan tetap melakukannya. Aktifkan Tautan Pembuatan Kode Waktu untuk MSVC, atau WOPR (saya pikir) untuk GCC, dan Anda akan membuatnya lebar program, yaitu bahkan dalam pemanggilan fungsi yang melintasi batas modul kode sumber.

Pada akhir hari semua hal di atas membuat kasus yang sangat solid untuk selalu lebih suka referensi ke petunjuk. Mereka semua lebih aman.

Const dengan int di kedua sisi akan membuat pointer ke int konstan :

const int *ptr=&i;

atau:

int const *ptr=&i;

constsetelah itu *akan membuat pointer konstan ke int :

int *const ptr=&i;

Dalam hal ini semua ini adalah pointer ke integer konstan , tetapi tidak satupun dari ini adalah pointer konstan:

 const int *ptr1=&i, *ptr2=&j;

Dalam hal ini semua adalah pointer ke integer konstan dan ptr2 adalah pointer konstan ke integer konstan . Tapi ptr1 bukan pointer konstan:

int const *ptr1=&i, *const ptr2=&j;

• jika constadalah ke kiri dari *, mengacu pada nilai (tidak peduli apakah itu const intatau int const)
• jika constadalah di sebelah kanan dari *, itu mengacu pada pointer itu sendiri
• keduanya bisa sekaligus

Poin penting: const int *p tidak berarti nilai yang Anda maksud adalah konstan !! . Ini berarti bahwa Anda tidak dapat mengubahnya melalui pointer itu (artinya, Anda tidak dapat menetapkan $ * p = ... `). Nilai itu sendiri dapat diubah dengan cara lain. Misalnya

int x = 5;
const int *p = &x;
x = 6; //legal
printf("%d", *p) // prints 6
*p = 7; //error 

Ini dimaksudkan untuk digunakan sebagian besar dalam tanda tangan fungsi, untuk menjamin bahwa fungsi tidak dapat secara tidak sengaja mengubah argumen yang disahkan.

Hanya demi kelengkapan untuk C mengikuti penjelasan yang lain, tidak yakin untuk C ++.

• pp - pointer ke pointer
• p - pointer
• data - hal yang runcing, dalam contoh x
• bold - variabel read-only

Pointer

• data p - int *p;
• data p -int const *p;
• data p -int * const p;
• data p -int const * const p;

Pointer ke pointer

1. data pp p - int **pp;
2. data pp p -int ** const pp;
3. data pp p -int * const *pp;
4. data pp p -int const **pp;
5. data pp p -int * const * const pp;
6. data pp p -int const ** const pp;
7. data pp p -int const * const *pp;
8. data pp p -int const * const * const pp;

// Example 1
int x;
x = 10;
int *p = NULL;
p = &x;
int **pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 2
int x;
x = 10;
int *p = NULL;
p = &x;
int ** const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 3
int x;
x = 10;
int * const p = &x; // Definition must happen during declaration
int * const *pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 4
int const x = 10; // Definition must happen during declaration
int const * p = NULL;
p = &x;
int const **pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 5
int x;
x = 10;
int * const p = &x; // Definition must happen during declaration
int * const * const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 6
int const x = 10; // Definition must happen during declaration
int const *p = NULL;
p = &x;
int const ** const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 7
int const x = 10; // Definition must happen during declaration
int const * const p = &x; // Definition must happen during declaration
int const * const *pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 8
int const x = 10; // Definition must happen during declaration
int const * const p = &x; // Definition must happen during declaration
int const * const * const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

N-level Dereferensi

Teruslah berjalan, tetapi semoga manusia mengucilkan Anda.

int x = 10;
int *p = &x;
int **pp = &p;
int ***ppp = &pp;
int ****pppp = &ppp;

printf("%d \n", ****pppp);

1. const int*- penunjuk ke intobjek konstan .

Anda dapat mengubah nilai pointer; Anda tidak dapat mengubah nilai intobjek, pointer menunjuk ke.

2. const int * const- pointer konstan ke intobjek konstan .

Anda tidak dapat mengubah nilai pointer atau nilai intobjek yang ditunjuk pointer.

3. int const *- penunjuk ke intobjek konstan .

Pernyataan ini setara dengan 1. const int*- Anda dapat mengubah nilai pointer tetapi Anda tidak dapat mengubah nilai intobjek, pointer menunjuk ke.

Sebenarnya, ada opsi ke-4:

4. int * const- pointer konstan ke intobjek.

Anda dapat mengubah nilai objek yang ditunjuk oleh pointer tetapi Anda tidak dapat mengubah nilai pointer itu sendiri. Pointer akan selalu mengarah ke intobjek yang sama tetapi nilai intobjek ini dapat diubah.

Jika Anda ingin menentukan tipe C atau C ++ construct tertentu, Anda dapat menggunakan Aturan Searah / Spiral yang dibuat oleh David Anderson; tetapi tidak bingung dengan Anderson`s Rule yang dibuat oleh Ross J. Anderson, yang merupakan sesuatu yang sangat berbeda.