Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

volatile — qualificatore di tipo

`volatile` qualifica un tipo e dà rilevanza osservabile agli accessi effettuati tramite espressioni di quel tipo. Può essere utile per l’accesso all’hardware secondo le regole specifiche dell’implementazione, ma non offre atomicità né sincronizzazione tra thread.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

volatile T object;
T volatile object;
volatile T* pointer_to_volatile;
T* volatile volatile_pointer = nullptr;
const volatile T* read_only_volatile_pointer;

volatile è un qualificatore di tipo, come const. Le forme volatile T e T volatile sono equivalenti. Gli accessi tramite espressioni glvalue qualificate volatile fanno parte del comportamento osservabile del programma e devono rispettare le regole della macchina astratta. Non è un interruttore generico per disattivare le ottimizzazioni.

La semantica dettagliata di questi accessi è definita dall’implementazione. Un uso comune riguarda i registri hardware mappati in memoria, ma gli indirizzi validi, le dimensioni degli accessi e le barriere necessarie dipendono dalla piattaforma. volatile da solo non garantisce né una specifica istruzione del processore né l’esclusione della cache. Accedere a un oggetto definito come volatile tramite una glvalue non qualificata volatile causa comportamento indefinito.

In volatile int* p, il qualificatore si applica all’int puntato; in int* volatile p, si applica al puntatore stesso, non all’oggetto puntato. const volatile int* p impedisce di modificare il valore tramite *p, mantenendo la semantica di accesso volatile.

volatile non offre né atomicità né sincronizzazione tra thread. Non rende sicura una variabile flag condivisa: una data race comporta comunque comportamento indefinito. Per la comunicazione tra thread, usa operazioni atomiche o mutex appropriati.

In C++23, volatile in sé non è deprecato, ma sono deprecati, tra gli altri, ++ e -- sui tipi aritmetici e puntatore qualificati volatile, i parametri passati per valore e i tipi restituiti da funzioni con volatile di livello superiore, nonché le dichiarazioni di structured binding con volatile. L’esempio usa una normale assegnazione e lettura. Le fonti fornite sono una bozza di standard in evoluzione, non una pubblicazione C++23 definitiva.

Esempi

#include <iostream>

int main() {
    volatile int value = 7;
    volatile int* p = &value;
    *p = 9;
    const int snapshot = *p;
    std::cout << snapshot << '\n';
}

Risultato

9

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti