C++ Volatile Typ Quantifizierer Position in variabler Definition

Question

Ich habe einige Nachforschungen gemacht und habe keine gute Antwort gefunden, und ich hoffe auf ein besseres Verständnis. Ich weiß, wie man volatile verwendet, aber habe eine Frage darüber, was es tut, wenn seine Platzierung in Variablendeklarationen unterschiedlich ist.

• volatile int * ptr;

Die ganze Zahl wies volatile und ist beim Lesen/an diesem Speicherplatz Schreiben auf die Speicherstelle gehen immer.

• int * volatile ptr;

Der Wert Zeiger selbst ist volatile und beim Lesen/Schreiben immer an diesen Speicherplatz auf den Speicherplatz gehen.

Es ist ein feiner Unterschied, aber von dem, was ich den Unterschied sagen kann, ist so etwas.

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) 
------------------------ 

Meine Frage ist, was passiert, wenn das flüchtige quantifier nicht auf einem Zeigertyp ist, zum Beispiel.

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. 
------------------------ 

Sind diese beiden Deklarationen nicht dasselbe für Non-Pointer-Deklarationen?

Answer 1

Ja, die Reihenfolge der Modifizierer-Schlüsselwörter ist flexibel. Es macht das gleiche links oder rechts vom Typ. Das gleiche gilt für const.

Ich ziehe den Modifikator nach die Art, weil es Ihnen von rechts zu lesen erlaubt nach links auf die Ebene-Englisch-Definition zu erhalten.

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" 

Also ich selbst standardisieren auf

int volatile foo;