const e puntatori volatili
const e volatile le parole chiave modificano come puntatori vengono considerati.const la parola chiave specifica che il puntatore non può essere modificato dopo l'inizializzazione, il puntatore viene successivamente protetto da modifiche.
volatile la parola chiave specifica che il valore associato al nome di seguito può essere modificato mediante azioni diverso da quelli dell'utente.di conseguenza, volatile la parola chiave è utile per la dichiarazione di oggetti in memoria condivisa che può essere eseguito da più processi o le aree dati globali utilizzati per la comunicazione con le routine di servizio di interruzione.
Quando un nome è dichiarata come volatile, il compilatore ricarica il valore dalla memoria ogni volta che si accede dal programma.In questo modo si riduce notevolmente le ottimizzazioni possibili.Tuttavia, quando lo stato di un oggetto può cambiare in modo imprevisto, è l'unico modo per garantire che le prestazioni del programma prevedibili.
Per dichiarare l'oggetto a cui fa riferimento il puntatore come const o volatile, utilizzare una dichiarazione del form:
const char *cpch;
volatile char *vpch;
Per dichiarare il valore del puntatore, ovvero effettivo indirizzo archiviato nel puntatore - come const o volatile, utilizzare una dichiarazione del form:
char * const pchc;
char * volatile pchv;
Il linguaggio C++ impedisce le assegnazioni che permetterebbero la modifica di un oggetto o di un puntatore dichiarata come const.Queste assegnazioni rimuoverebbero le informazioni che l'oggetto o il puntatore è stato dichiarato con, è violanti lo scopo della dichiarazione originale.Si considerino le seguenti dichiarazioni:
const char cch = 'A';
char ch = 'B';
Date le dichiarazioni precedenti di due oggetti (cch, di tipo conste ch, di tipo char), la seguente dichiarazione/inizializzazioni sono valide:
const char *pch1 = &cch;
const char *const pch4 = &cch;
const char *pch5 = &ch;
char *pch6 = &ch;
char *const pch7 = &ch;
const char *const pch8 = &ch;
La seguente dichiarazione/inizializzazioni è erronee.
char *pch2 = &cch; // Error
char *const pch3 = &cch; // Error
la dichiarazione di pch2 dichiara un puntatore in cui un oggetto costante potrebbe essere modificato e pertanto è disattivata.la dichiarazione di pch3 specifica che pointer è costante, non l'oggetto; la dichiarazione è consentita per lo stesso motivo pch2 la dichiarazione non è consentita.
Le seguenti otto assegnazioni mostrano assegnare tramite il puntatore e la modifica del valore del puntatore per le dichiarazioni precedenti; per ora, si supponga che l'inizializzazione è stata corregge pch1 in pch8.
*pch1 = 'A'; // Error: object declared const
pch1 = &ch; // OK: pointer not declared const
*pch2 = 'A'; // OK: normal pointer
pch2 = &ch; // OK: normal pointer
*pch3 = 'A'; // OK: object not declared const
pch3 = &ch; // Error: pointer declared const
*pch4 = 'A'; // Error: object declared const
pch4 = &ch; // Error: pointer declared const
Puntatori dichiarati come volatile, o come combinazione di const e volatile, obbedire le stesse regole.
puntatori a const gli oggetti vengono spesso utilizzati nelle dichiarazioni di funzione come segue:
errno_t strcpy_s( char *strDestination, size_t numberOfElements, const char *strSource );
L'istruzione precedente viene dichiarata una funzione, strcpy_s, in cui due dei tre argomenti sono di tipo puntatore char.Poiché gli argomenti vengono passati per riferimento e non per valore, la funzione sarebbe libera di modificare entrambe strDestination e strSource se strSource non sono stati dichiarati come const.la dichiarazione di strSource come const garantisce il chiamante quello strSource non può essere modificato dalla funzione chiamata.
[!NOTA]
Poiché è una conversione standard da typename * in const typename *, è valido per passare un argomento di tipo char * in strcpy_s.Tuttavia, l'opposto non è true, nessuna conversione implicita esiste per rimuovere const attributo da un oggetto o da un puntatore.
In const il puntatore di un tipo specificato può essere assegnato a un puntatore dello stesso tipo.Tuttavia, un puntatore non const non può essere assegnato a const puntatore.Il codice riportato di seguito vengono illustrate le assegnazioni corrette e errate:
// const_pointer.cpp
int *const cpObject = 0;
int *pObject;
int main() {
pObject = cpObject;
cpObject = pObject; // C3892
}
Di seguito viene illustrato come dichiarare un oggetto come const se si dispone di un puntatore a un puntatore a un oggetto.
// const_pointer2.cpp
struct X {
X(int i) : m_i(i) { }
int m_i;
};
int main() {
// correct
const X cx(10);
const X * pcx = &cx;
const X ** ppcx = &pcx;
// also correct
X const cx2(20);
X const * pcx2 = &cx2;
X const ** ppcx2 = &pcx2;
}