const riferimento e const puntatore. Come funzionano?

Ci sono due aspetti di const in C ++:

• costanza logica: quando si crea una variabile e si punta un puntatore const o un riferimento ad esso, il compilatore controlla semplicemente che non si modifichi la variabile tramite il puntatore% o il riferimento%, direttamente o indirettamente. Questa costanza può essere scartata con una const . In quanto tale, il seguente codice è perfettamente legale:

  char myString[] = "Hallo Welt!";    //copy the string into an array on the stack
  const char* constPtr = myString;
  const_cast<char*>(constPtr)[i] = 'e';    //perfectly legal
  

• costanza fisica: quando si crea una variabile nell'archivio statico che è const_cast<> , si consente al compilatore di inserire una memoria non scrivibile. Potrebbe farlo, o potrebbe non farlo. Per quanto riguarda lo standard, si sta semplicemente invocando un comportamento indefinito se si esegue il cast della costanza per modificare tale oggetto. Questo include tutti i valori letterali di stringa, quindi il codice seguente potrebbe o potrebbe non funzionare:

   const char* myString = "Hallo World!";
   const_cast<char*>(myString)[1] = 'e';     //Undefined behavior, modifying a const static object!
  

Quando si usa il qualificatore const nel caso seguente:

 const int value=67;

Stiamo dicendo al compilatore che promettiamo di non cambiare il valore della variabile "valore". In quanto tale, il compilatore sostituirà semplicemente le istanze di "valore" con il valore effettivo con cui lo inizializziamo. Dal momento che il compilatore sostituisce ogni istanza della variabile con il suo valore effettivo, dobbiamo inizializzarlo.

  const int k; //error,must be initialized.

quando si limita questo valore a un riferimento, il riferimento deve avere un qualificatore per garantire che non si modifichi il valore associato a tramite il riferimento (riferimento lvalue).

 const int& c1=value;
 c1=56; //error,we cannot modify it through the reference.

ma possiamo anche associare un valore non const a un riferimento const ...

int i=89;
const int& ic=i; //const lvalue-ref
int& ir=i;
ir=7; //ok.ir is not const
ic=67990; //error ic is const

Come per i puntatori:

 const int val=90;
 int* valp=&val;//error the pointer is not const.
 const int* val2p=&val;//ok as they are both const
 *val2p =788;//error as it is a pointer to non-writable space

Tuttavia, un puntatore a un const può essere usato per puntare a un oggetto non const. L'idea è che i puntatori ei riferimenti a const "pensano che puntino o si riferiscano a oggetti const".

A differenza dei riferimenti, i puntatori sono oggetti e possono essere resi const. Significa che un puntatore può essere fatto puntare a una particolare memoria e non essere autorizzato a puntare su un'altra memoria una volta inizializzata.

 int* const x=&val;//it will point to that memory location only.

Il fatto che "x" sia esso stesso un puntatore non dice nulla sul valore a cui punta.

L'altro caso interessante è il caso "constexpr":

 constexpr int* i=nullptr; //it is the pointer that is const.not the value it points to
 constexpt const int* ii=&value; //both are const in this case.

In senso stretto, const x chiede semplicemente al compilatore di verificare in fase di compilazione che tu non stia cambiando x dopo la sua definizione iniziale. Ciò non implica alcuna modifica al comportamento di runtime del programma, né alcun requisito per memorizzare il valore di x in modo diverso. Un compilatore intelligente proverà a trarne vantaggio per alcune ottimizzazioni, ma nel caso generale il codice macchina generato per un valore const, puntatore o riferimento potrebbe essere esattamente lo stesso di un valore, puntatore o riferimento non-const. L'unica distinzione tra const char* e char* const è che il compilatore esegue un controllo diverso.

In effetti, l'ottimizzazione principale qui non sta mettendo "variabili const" nella memoria di programma statico di sola lettura, ma mettendo valori letterali lì. Nell'esempio che hai fornito, è probabile che i caratteri 'z' e '9' esistano da qualche parte nel binario compilato, indipendentemente da quali variabili hai fatto o non hai usato la parola chiave const su. Se usi stringhe più lunghe, dovresti riuscire a trovarle nel binario abbastanza facilmente con un editor esadecimale.

Quando assegni quel letterale a const x , il compilatore proverà probabilmente a eseguire l'ottimizzazione aggiuntiva di non rappresentare x come una posizione separata in memoria, e interpreterà invece tutte le letture di x come letture di quel letterale valore nel codice del programma. Ma probabilmente proverebbe a farlo anche se x è stato non-const, dal momento che può ancora vedere che non gli hai mai assegnato nulla (se non lo fosse, non sarebbe in grado di forzare x const - quando lo si dichiara const ). Ed è probabilmente anche la memorizzazione di alcuni valori intermedi nei registri della CPU per evitare di leggere da qualsiasi memoria, quindi il codice effettivo della macchina varierà piuttosto selvaggiamente.

Vale la pena notare che un lotto di funzionalità C ++ funziona allo stesso modo. Un metodo di classe privato è anche "solo" un controllo in fase di compilazione.

La parola chiave Const è direttiva per il compilatore che il suo valore iniziale non cambierà mai. Il compilatore verifica se durante la compilazione il programma sta modificando il valore in qualche modo. Per favore, chiarisci le tue conoscenze sulle variabili costanti e le variabili protette da scrittura sono cose completamente diverse. È simile alla definizione da manuale di "Variabile"

In programming, a variable is a value that can change, depending on conditions or on information passed to the program. Typically, a program consists of instruction s that tell the computer what to do and data that the program uses when it is running.

Ma in realtà le variabili sono il nome dato alla posizione di memoria e può anche essere costante.