CKTIS / C++
volatile — qualificatif de type
`volatile` qualifie un type et confère une signification observable aux accès effectués par de telles expressions. Il peut servir aux accès matériels selon les règles propres à l’implémentation, mais ne fournit ni atomicité ni synchronisation entre threads.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
volatile T object;
T volatile object;
volatile T* pointer_to_volatile;
T* volatile volatile_pointer = nullptr;
const volatile T* read_only_volatile_pointer;volatile est un qualificatif de type, comme const. Les écritures volatile T et T volatile sont équivalentes. Les accès effectués par des expressions glvalue qualifiées volatile font partie du comportement observable du programme et doivent respecter les règles de la machine abstraite. Ce n’est pas un interrupteur général qui désactive les optimisations.
La sémantique détaillée de ces accès dépend de l’implémentation. Les registres matériels mappés en mémoire constituent un usage courant, mais les adresses valides, les largeurs d’accès et les barrières requises dépendent de la plateforme. À lui seul, volatile ne garantit ni une instruction particulière du processeur ni le contournement du cache. Accéder à un objet défini comme volatile par une glvalue non qualifiée volatile entraîne un comportement indéfini.
Dans volatile int* p, le qualificatif s’applique au int pointé ; dans int* volatile p, il s’applique au pointeur lui-même, et non à l’objet pointé. const volatile int* p interdit la modification via *p, tout en conservant la sémantique d’accès volatile.
volatile ne fournit ni atomicité ni synchronisation entre threads. Il ne rend pas sûre une variable indicatrice partagée : une course de données entraîne toujours un comportement indéfini. Pour communiquer entre threads, utilisez des opérations atomiques ou des mutex appropriés.
En C++23, volatile lui-même n’est pas obsolète, mais le sont notamment ++ et -- sur des types arithmétiques et pointeurs qualifiés volatile, les paramètres passés par valeur et les types de retour de fonction avec volatile de premier niveau, ainsi que les déclarations de liaisons structurées avec volatile. L’exemple utilise une affectation et une lecture ordinaires. Les sources fournies sont un projet de norme en évolution, et non une publication C++23 figée.
Exemples
#include <iostream>
int main() {
volatile int value = 7;
volatile int* p = &value;
*p = 9;
const int snapshot = *p;
std::cout << snapshot << '\n';
}
Résultat
9
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.