Qual è la differenza tra char * const e const char *?

Qual è la differenza tra:

char * const 

e

 const char * 

La differenza è che const char * è un puntatore a un const char , mentre char * const è un puntatore costante a un char .

Il primo, il cui valore non può essere modificato, ma il puntatore può essere. Il secondo, il valore puntato su può cambiare ma il puntatore non può (simile a un riferimento).

C’è anche un

 const char * const 

che è un puntatore costante a un carattere costante (quindi nulla può essere modificato).

Nota:

Le seguenti due forms sono equivalenti:

 const char * 

e

 char const * 

La ragione esatta di ciò è descritta nello standard C ++, ma è importante notare ed evitare la confusione. Conosco diversi standard di codifica che preferiscono:

 char const 

al di sopra di

 const char 

(con o senza puntatore) in modo che il posizionamento dell’elemento const sia lo stesso di un const puntatore.

Per evitare confusione, aggiungi sempre il qualificatore 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 modifica sempre la cosa che viene prima di essa (alla sua sinistra), TRANNE quando è la prima cosa in una dichiarazione di tipo, dove modifica la cosa che viene dopo di essa (alla sua destra).

Quindi questi due sono gli stessi:

 int const *i1; const int *i2; 

definiscono i puntatori a un const int . È ansible modificare i punti i1 e i2 , ma non è ansible modificare il valore a cui puntano.

Questo:

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

definisce un puntatore const su un numero intero e lo inizializza in modo che punti alla posizione di memoria 12345678. È ansible modificare il valore int all’indirizzo 12345678, ma non è ansible modificare l’indirizzo a cui punta i3 .

const * char è un codice C non valido e non ha senso. Forse volevi chiedere la differenza tra un const char * e un char const * , o forse la differenza tra un const char * e un char * const ?

Guarda anche:

  • Cosa sono i puntatori const (al contrario dei puntatori agli oggetti const)?
  • Const in C
  • Differenza tra dichiarazioni const in C ++
  • Domanda const C ++
  • Perché posso modificare i valori di una variabile const char *?

const char* è un puntatore a un carattere costante
char* const è un puntatore costante a un personaggio
const char* const è un puntatore costante a un carattere costante

1) const char * x Here X è fondamentalmente un puntatore di caratteri che punta a un valore costante

2) char * const x si riferisce al puntatore di caratteri che è costante, ma la posizione che sta puntando può essere cambiata.

3) const char * const x è una combinazione di 1 e 2, significa che è un puntatore di carattere costante che punta al valore costante.

4) const * char x causerà un errore del compilatore. non può essere dichiarato.

5) char const * x è uguale al punto 1.

la regola generale è se const è con nome var, quindi il puntatore sarà costante ma la posizione di puntamento può essere modificata , altrimenti il puntatore punterà a una posizione costante e il puntatore può puntare a un’altra posizione ma il contenuto della posizione di puntamento non può essere modificato .

Regola generale: leggi la definizione da destra a sinistra!


const int *foo;

Significa “punti foo ( * ) per un int che non può cambiare ( const )”.
Per il programmatore ciò significa “Non cambierò il valore di ciò che foo punta a”.

  • *foo = 123; o foo[0] = 123; non sarebbe valido
  • foo = &bar; È permesso.

int *const foo;

Significa che ” foo non può cambiare ( const ) e punti ( * ) in un int “.
Per il programmatore ciò significa “Non cambierò l’ indirizzo di memoria a cui si riferisce foo “.

  • *foo = 123; o foo[0] = 123; È permesso.
  • foo = &bar; non sarebbe valido

const int *const foo;

Significa che ” foo non può cambiare ( const ) e points ( * ) in un int che non può cambiare ( const )”.
Per il programmatore ciò significa “Non cambierò il valore di ciò a cui punta foo , né cambierò l’ indirizzo a cui si riferisce foo “.

  • *foo = 123; o foo[0] = 123; non sarebbe valido
  • foo = &bar; non sarebbe valido

Il primo è un errore di syntax. Forse intendevi la differenza tra

 const char * mychar 

e

 char * const mychar 

In questo caso, il primo è un puntatore a dati che non possono essere modificati e il secondo è un puntatore che punta sempre allo stesso indirizzo.

Un’altra regola del pollice è controllare dove const è :

  1. prima * => il valore memorizzato è costante
  2. dopo * => il puntatore stesso è costante

Un sacco di risposte forniscono tecniche specifiche, regole empiriche ecc per comprendere questa particolare istanza di dichiarazione delle variabili. Ma esiste una tecnica generica per comprendere qualsiasi dichiarazione:

Regola in senso orario / a spirale

UN)

 const char *a; 

Come per la regola in senso orario / spirale a è puntatore al carattere che è costante. Il che significa che il carattere è costante ma il puntatore può cambiare. cioè a = "other string"; va bene ma a[2] = 'c'; non riuscirà a compilare

B)

 char * const a; 

Secondo la regola, a è a puntatore const su un personaggio. cioè puoi fare a[2] = 'c'; ma non puoi fare a = "other string";

Presumo tu intenda const char * e char * const.

Il primo, const char *, è un puntatore a un carattere costante. Il puntatore stesso è mutabile.

Il secondo, char * const è un puntatore costante a un personaggio. Il puntatore non può cambiare, il carattere a cui punta.

E poi c’è const char * const in cui il puntatore e il carattere non possono cambiare.

Ecco una spiegazione dettagliata con il codice

 /*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 /*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; }*/ 
  1. Puntatore costante: un puntatore costante può puntare solo a una singola variabile del rispettivo tipo di dati durante l’intero programma. Possiamo cambiare il valore della variabile puntata dal puntatore. L’inizializzazione dovrebbe essere fatta durante il tempo della dichiarazione stessa.

Sintassi:

 datatype *const var; 

char *const rientra in questo caso.

 /*program to illustrate the behaviour of constant pointer */ #include 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; } 
  1. Puntatore a un valore const : in questo un puntatore può puntare qualsiasi numero di variabili del rispettivo tipo ma non è ansible modificare il valore dell’object puntato dal puntatore in quel momento specifico.

Sintassi:

const datatype *var o datatype const *var

const char* rientra in questo caso.

 /* program to illustrate the behavior of pointer to a constant*/ #include int main(){ int a=10,b=20; int const *ptr=&a; printf("%d\n",*ptr); /* *ptr=100 is not possible ie 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 e const char *?

  1. Indicando un valore costante

const char * p; // il valore non può essere modificato

  1. Puntatore costante a un valore

char * const p; // l’indirizzo non può essere cambiato

  1. Puntatore costante a un valore costante

const char * const p; // entrambi non possono essere modificati.

Il modificatore const viene applicato al termine immediatamente alla sua sinistra. L’unica eccezione è quando non c’è nulla alla sua sinistra, quindi si applica a ciò che è immediatamente alla sua destra.

Questi sono tutti modi equivalenti per dire “puntatore costante a un char costante”:

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

Due regole

  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.

per esempio

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

Vorrei sottolineare che l’uso di int const * (o const int * ) non riguarda un puntatore che punta a una variabile const int , ma che questa variabile è const per questo puntatore specifico.

Per esempio:

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

Il codice sopra compila perfettamente bene. _p punta a una variabile const , sebbene var stesso non sia costante.

 // 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' }