C++ Volatile Tipo Quantificatore Posizione in variabile Definizione

Question

Ho fatto qualche ricerca e non ho trovato una buona risposta e spero di capire meglio. So come usare volatile ma ho una domanda su cosa fa quando il suo posizionamento è diverso nelle dichiarazioni delle variabili, per esempio.

• volatile int * ptr;

Il numero intero puntato è volatile e durante la lettura/scrittura a questa posizione di memoria sempre andare alla posizione di memoria.

• int * volatile ptr;

Il valore del puntatore stesso è volatile e durante la lettura/scrittura a questa posizione di memoria sempre andare alla posizione di memoria.

È una sottile differenza, ma da quello che posso dire la differenza è qualcosa di simile.

volatile int * foo; 
int * volatile bar; 
volatile int testInt = 5; 
------------------------ 
|   0x020   | - 0x000 (foo), memory location 0x000 can be cached. 
------------------------ 
|   0x020   | - 0x010 (bar), memory location 0x010 can't be cached. 
------------------------ 
|   5   | - 0x020 (testInt) 
------------------------ 

La mia domanda è cosa se il quantificatore volatile non è su un tipo di puntatore, ad esempio.

volatile int foo = 5; 
int volatile bar = 5; 
------------------------ 
|   5   | - 0x000 (foo), memory location 0x000 can't be cached. 
------------------------ 
|   5   | - 0x004 (bar), memory location 0x004 can't be cached. 
------------------------ 

Queste due dichiarazioni non fanno la stessa cosa per le dichiarazioni non puntatore?

Answer 1

Sì, l'ordine delle parole chiave del modificatore è flessibile. Fa la stessa cosa a sinistra oa destra del tipo. La stessa cosa vale per const.

preferisco il modificatore dopo tipo, perché permette di leggere da destra a sinistra per ottenere la definizione plain-inglese.

int volatile * foo; // "foo is a pointer to a volatile int" 
int * volatile foo; // "foo is a volatile pointer to an int" 
int const * foo; // "foo is a pointer to a constant int" 
int * const foo; // "foo is a constant pointer to an int" 

Così mi auto-standardizzare su

int volatile foo;