Pourquoi un pointeur de type "volatile", comme "volatile int * p", est-il utile ?

Question

volatile est de dire au compilateur de ne pas optimiser la référence, de sorte que chaque lecture/écriture n'utilise pas la valeur stockée dans le registre mais fait un accès réel à la mémoire. Je peux comprendre que c'est utile pour certaines variables ordinaires, mais je ne comprends pas comment volatile affecte un pointeur.

volatile int *p = some_addr;
int a = *p; // CPU always has to load the address, then does a memory access anyway, right?

Quelle est la différence si elle a été déclarée en tant que int *p = some_addr ?

Answer 1

Un pointeur de la forme

volatile int* p;

est un pointeur vers un int que le compilateur traitera comme volatile . Cela signifie que le compilateur supposera qu'il est possible pour la variable que p a été modifié, même si rien dans le code source ne suggère que cela puisse se produire. Par exemple, si je définis p pour pointer vers un entier normal, alors chaque fois que je lis ou écris *p le compilateur est conscient que la valeur peut avoir changé de manière inattendue.

Il existe un autre cas d'utilisation d'un volatile int* : Si vous déclarez un int comme volatile alors vous ne devez pas le pointer avec un habituel int* . Par exemple, c'est une mauvaise idée :

volatile int myVolatileInt;
int* ptr = &myVolatileInt; // Bad idea!

La raison en est que le compilateur C ne se souvient plus que la variable pointée par ptr est volatile il peut donc mettre en cache la valeur de *ptr dans un registre de manière incorrecte. En fait, en C++, le code ci-dessus est une erreur. Au lieu de cela, vous devriez écrire :

volatile int myVolatileInt;
volatile int* ptr = &myVolatileInt; // Much better!

Maintenant, le compilateur se souvient que ptr points à un volatile int Il n'essaiera donc pas (ou ne devrait pas !) d'optimiser les accès par le biais de l'option *ptr .

Un dernier détail - le pointeur dont vous avez parlé est un pointeur vers un volatile int . Vous pouvez également le faire :

int* volatile ptr;

Cela signifie que le pointeur lui-même est volatile Ce qui signifie que le compilateur ne doit pas essayer de mettre en cache le pointeur en mémoire ou d'optimiser la valeur du pointeur parce que le pointeur lui-même pourrait être réaffecté par quelque chose d'autre (matériel, etc.) Vous pouvez combiner ces deux éléments si vous souhaitez obtenir cette bête :

volatile int* volatile ptr;

Le compilateur ne peut pas optimiser le pointeur lui-même, et il ne peut pas optimiser ce qui est pointé.

J'espère que cela vous aidera !

Answer 2

Ce code volatile int *p = some_addr déclare un pointeur vers un volatile int . Le pointeur lui-même n'est pas volatile .

Dans le cas peu probable où vous auriez besoin que le pointeur soit volatile en plus de l'int, vous devriez utiliser :

volatile int * volatile p;

Je ne peux pas imaginer une situation où vous auriez besoin de l'utiliser.

Answer 3

Sur l'utilité du volatile : C'est nécessaire, si vous avez besoin de vérifier la mémoire, qui est modifiée par le matériel comme un contrôleur d'interface série. Elle a son application dans le monde des systèmes embarqués, où l'on travaille très près du matériel sans aucun système d'exploitation entre les deux.

Answer 4

Un pointeur est une variable qui contient l'adresse d'une autre variable, donc selon votre description de volatile, la mémoire sera accédée deux fois.