Apa perbedaan antara:

char * const 

dan

const char *

Perbedaannya adalah bahwa itu const char *adalah pointer ke const char, sedangkan char * constadalah pointer konstan ke a char.

Yang pertama, nilai yang ditunjuk tidak bisa diubah tetapi pointer bisa. Yang kedua, nilai yang ditunjukkan bisa berubah tetapi pointer tidak bisa (mirip dengan referensi).

Ada juga a

const char * const

yang merupakan pointer konstan ke char konstan (jadi tidak ada yang bisa diubah).

catatan:

Dua bentuk berikut ini setara:

const char *

dan

char const *

Alasan yang tepat untuk ini dijelaskan dalam standar C ++, tetapi penting untuk mencatat dan menghindari kebingungan. Saya tahu beberapa standar pengkodean yang lebih suka:

char const

lebih

const char

(dengan atau tanpa pointer) sehingga penempatan constelemen sama dengan pointer const.

Untuk menghindari kebingungan, selalu tambahkan kualifikasi const.

int       *      mutable_pointer_to_mutable_int;
int const *      mutable_pointer_to_constant_int;
int       *const constant_pointer_to_mutable_int;
int const *const constant_pointer_to_constant_int;

const selalu memodifikasi hal yang datang sebelum itu (di sebelah kiri itu), KECUALI ketika itu adalah hal pertama dalam deklarasi tipe, di mana ia memodifikasi hal yang datang setelah itu (di sebelah kanannya).

Jadi keduanya sama:

int const *i1;
const int *i2;

mereka mendefinisikan pointer ke a const int. Anda dapat mengubah tempat i1dan i2titik, tetapi Anda tidak dapat mengubah nilai yang mereka tunjukkan.

Ini:

int *const i3 = (int*) 0x12345678;

mendefinisikan constpointer ke integer dan menginisialisasi untuk menunjuk di lokasi memori 12345678. Anda dapat mengubah intnilai di alamat 12345678, tetapi Anda tidak dapat mengubah alamat yang i3menunjuk ke.

const * charkode C tidak valid dan tidak berarti. Mungkin Anda bermaksud menanyakan perbedaan antara a const char *dan a char const *, atau mungkin perbedaan antara a const char *dan a char * const?

Lihat juga:

• Apa itu pointer pointer (berbeda dengan pointer ke objek const)?
• Const dalam C
• Perbedaan antara deklarasi const di C ++
• C ++ const pertanyaan
• Mengapa saya bisa mengubah nilai-nilai variabel const char *?

const char*adalah pointer ke karakter konstan
char* constadalah pointer konstan ke karakter
const char* constadalah pointer konstan ke karakter konstan

Rule of thumb: baca definisi dari kanan ke kiri!

const int *foo;

Berarti " foomenunjuk ( *) ke intyang tidak dapat mengubah ( const)".
Untuk programmer ini berarti "Saya tidak akan mengubah nilai apa yang foomenunjuk ke".

• *foo = 123;atau foo[0] = 123;tidak valid.
• foo = &bar; Diperbolehkan.

int *const foo;

Berarti " footidak dapat mengubah ( const) dan menunjuk ( *) ke sebuah int".
Untuk programmer ini berarti "Saya tidak akan mengubah alamat memori yang foomerujuk".

• *foo = 123;atau foo[0] = 123;diizinkan.
• foo = &bar; akan menjadi tidak valid.

const int *const foo;

Berarti " footidak dapat mengubah ( const) dan menunjuk ( *) ke intyang tidak dapat mengubah ( const)".
Bagi programmer, ini berarti "Saya tidak akan mengubah nilai dari foopoin apa , atau mengubah alamat yang foomerujuk".

• *foo = 123;atau foo[0] = 123;tidak valid.
• foo = &bar; akan menjadi tidak valid.

1. const char * x Di sini X pada dasarnya adalah penunjuk karakter yang menunjuk ke nilai konstan

2. char * const x merujuk ke penunjuk karakter yang konstan, tetapi lokasi yang ditunjuknya dapat berubah.

3. const char * const x adalah kombinasi ke 1 dan 2, berarti itu adalah penunjuk karakter konstan yang menunjuk ke nilai konstan.

4. const * char x akan menyebabkan kesalahan kompiler. itu tidak bisa dinyatakan.

5. char const * x sama dengan poin 1.

aturan praktisnya adalah jika const adalah dengan nama var maka pointer akan konstan tetapi lokasi menunjuk dapat diubah , jika pointer akan menunjuk ke lokasi konstan dan pointer dapat menunjuk ke lokasi lain tetapi konten lokasi yang menunjuk tidak dapat diubah .

Yang pertama adalah kesalahan sintaksis. Mungkin maksud Anda perbedaannya

const char * mychar

dan

char * const mychar

Dalam hal itu, yang pertama adalah pointer ke data yang tidak bisa berubah, dan yang kedua adalah pointer yang akan selalu menunjuk ke alamat yang sama.

Aturan praktis lainnya adalah untuk mengecek letak const :

1. sebelum * => nilai yang disimpan konstan
2. setelah * => pointer itu sendiri adalah konstan

Banyak jawaban memberikan teknik khusus, aturan praktis dll untuk memahami contoh khusus dari deklarasi variabel ini. Tetapi ada teknik umum untuk memahami pernyataan apa pun:

Searah Jarum Jam / Aturan Spiral

SEBUAH)

const char *a;

Sesuai aturan jarum jam / spiral aadalah penunjuk ke karakter yang konstan. Yang berarti karakter konstan tetapi pointer dapat berubah. yaitu a = "other string";baik-baik saja tetapi a[2] = 'c';akan gagal dikompilasi

B)

char * const a;

Sesuai aturan, aadalah pointer pointer ke karakter. yaitu Anda dapat melakukan a[2] = 'c';tetapi Anda tidak bisa melakukannyaa = "other string";

Saya kira maksudmu const char * dan char * const.

Yang pertama, const char *, adalah penunjuk ke karakter konstan. Pointer itu sendiri bisa berubah.

Yang kedua, char * const adalah pointer konstan ke karakter. Pointer tidak dapat berubah, karakter yang ditunjukkannya bisa.

Dan kemudian ada const char * const di mana pointer dan karakter tidak dapat berubah.

Berikut adalah penjelasan terperinci dengan kode

/*const char * p;
char * const p; 
const char * const p;*/ // these are the three conditions,

// const char *p;const char * const p; pointer value cannot be changed

// char * const p; pointer address cannot be changed

// const char * const p; both cannot be changed.

#include<stdio.h>

/*int main()
{
    const char * p; // value cannot be changed
    char z;
    //*p = 'c'; // this will not work
    p = &z;
    printf(" %c\n",*p);
    return 0;
}*/

/*int main()
{
    char * const p; // address cannot be changed
    char z;
    *p = 'c'; 
    //p = &z;   // this will not work
    printf(" %c\n",*p);
    return 0;
}*/



/*int main()
{
    const char * const p; // both address and value cannot be changed
    char z;
    *p = 'c'; // this will not work
    p = &z; // this will not work
    printf(" %c\n",*p);
    return 0;
}*/

// Some more complex constant variable/pointer declaration.
// Observing cases when we get error and warning would help
// understanding it better.

int main(void)
{
  char ca1[10]= "aaaa"; // char array 1
  char ca2[10]= "bbbb"; // char array 2

  char *pca1= ca1;
  char *pca2= ca2;

  char const *ccs= pca1;
  char * const csc= pca2;
  ccs[1]='m';  // Bad - error: assignment of read-only location ‘*(ccs + 1u)’
  ccs= csc;    // Good

  csc[1]='n';  // Good
  csc= ccs;    // Bad - error: assignment of read-only variable ‘csc’

  char const **ccss= &ccs;     // Good
  char const **ccss1= &csc;    // Bad - warning: initialization from incompatible pointer type

  char * const *cscs= &csc;    // Good
  char * const *cscs1= &ccs;   // Bad - warning: initialization from incompatible pointer type

  char ** const cssc=   &pca1; // Good
  char ** const cssc1=  &ccs;  // Bad - warning: initialization from incompatible pointer type
  char ** const cssc2=  &csc;  // Bad - warning: initialization discards ‘const’
                               //                qualifier from pointer target type

  *ccss[1]= 'x'; // Bad - error: assignment of read-only location ‘**(ccss + 8u)’
  *ccss= ccs;    // Good
  *ccss= csc;    // Good
  ccss= ccss1;   // Good
  ccss= cscs;    // Bad - warning: assignment from incompatible pointer type

  *cscs[1]= 'y'; // Good
  *cscs= ccs;    // Bad - error: assignment of read-only location ‘*cscs’
  *cscs= csc;    // Bad - error: assignment of read-only location ‘*cscs’
  cscs= cscs1;   // Good
  cscs= cssc;    // Good

  *cssc[1]= 'z'; // Good
  *cssc= ccs;    // Bad - warning: assignment discards ‘const’
                 //                qualifier from pointer target type
  *cssc= csc;    // Good
  *cssc= pca2;   // Good
  cssc= ccss;    // Bad - error: assignment of read-only variable ‘cssc’
  cssc= cscs;    // Bad - error: assignment of read-only variable ‘cssc’
  cssc= cssc1;   // Bad - error: assignment of read-only variable ‘cssc’
}

1. Pointer konstan : Pointer konstan dapat menunjuk hanya ke variabel tunggal dari masing-masing tipe data selama seluruh program. Kita dapat mengubah nilai variabel yang ditunjuk oleh pointer. Inisialisasi harus dilakukan selama waktu deklarasi itu sendiri.

Sintaksis:

datatype *const var;

char *const datang dalam kasus ini.

/*program to illustrate the behaviour of constant pointer */

#include<stdio.h>
int main(){
  int a=10;
  int *const ptr=&a;
  *ptr=100;/* we can change the value of object but we cannot point it to another variable.suppose another variable int b=20; and ptr=&b; gives you error*/
  printf("%d",*ptr);
  return 0;
}

2. Pointer ke nilai const : Dalam pointer ini dapat menunjukkan sejumlah variabel dari masing-masing jenis tetapi kita tidak dapat mengubah nilai objek yang ditunjuk oleh pointer pada waktu tertentu.

Sintaksis:

const datatype *varatau datatype const *var

const char* datang dalam kasus ini.

/* program to illustrate the behavior of pointer to a constant*/

   #include<stdio.h>
   int main(){
       int a=10,b=20;
       int const *ptr=&a;
       printf("%d\n",*ptr);
       /*  *ptr=100 is not possible i.e we cannot change the value of the object pointed by the pointer*/
       ptr=&b;
       printf("%d",*ptr);
       /*we can point it to another object*/
       return 0;
    }

char * const dan const char *?

1. Menunjuk ke nilai konstan

const char * p; // nilai tidak bisa diubah

2. Pointer konstan ke nilai

char * const p; // alamat tidak bisa diubah

3. Pointer konstan ke nilai konstan

const char * const p; // keduanya tidak bisa diubah.

The constpengubah diterapkan untuk jangka segera ke kiri nya. Satu-satunya pengecualian untuk ini adalah ketika tidak ada yang di sebelah kirinya, maka itu berlaku untuk apa yang ada di sebelah kanannya.

Ini semua adalah cara yang setara untuk mengatakan "pointer konstan ke konstanta char":

• const char * const
• const char const *
• char const * const
• char const const *

Dua aturan

1. If const is between char and *, it will affect the left one.
2. If const is not between char and *, it will affect the nearest one.

misalnya

1. char const *. This is a pointer points to a constant char.
2. char * const. This is a constant pointer points to a char.

Saya ingin menunjukkan bahwa menggunakan int const *(atau const int *) bukan tentang pointer yang menunjuk ke suatu const intvariabel, tetapi bahwa variabel ini adalah constuntuk pointer spesifik ini.

Sebagai contoh:

int var = 10;
int const * _p = &var;

Kode di atas mengkompilasi dengan sangat baik. _pmenunjuk ke suatu constvariabel, meskipun varitu sendiri tidak konstan.

Saya ingat dari buku Czech tentang C: baca deklarasi yang Anda mulai dengan variabel dan ke kiri. Sehingga untuk

char * const a;

Anda dapat membaca sebagai: " aadalah variabel tipe pointer konstan ke char",

char const * a;

Anda dapat membaca sebagai: " aadalah pointer ke variabel konstan tipe char. Saya harap ini membantu.

Bonus:

const char * const a;

Anda akan membaca seperti apointer konstan ke variabel konstan tipe char.