Sémantique des structures volatiles

Question

Suffit-il de déclarer une instance d'une structure de type de variable volatile (si ses champs sont accessibles en ré-entrant le code"), ou doit-on déclarer des champs spécifiques de la structure, alors que la volatilité?

Formulé différemment, quelles sont les différences sémantiques (le cas échéant) entre:

typdef struct {
  uint8_t bar;
} foo_t;

volatile foo_t foo_inst;

et

typedef struct{
  volatile uint8_t bar;
} foo_t;

foo_t foo_inst;

Je reconnais que la déclaration d'un pointeur de type de variable, alors que la volatilité (par exemple, volatile u_int8_t * foo) simplement en informe le compilateur que l'adresse pointée par foo peut changer, tout en ne faisant aucune déclaration à propos de la valeur pointée par foo. Il est clair pour moi si une analogie est titulaire pour la structure-les variables de type.

Answer 1

Dans votre exemple, les deux sont les mêmes. Mais les questions tournent autour de pointeurs.

Tout d'abord, volatile uint8_t *foo; n'dire au compilateur que la mémoire pointé est volatile. Si vous voulez marquer le pointeur lui-même comme volatile, vous aurez besoin de faire uint8_t * volatile foo;

Et c'est là que vous obtenez les principales différences entre le marquage de la structure, alors que la volatilité vs marquage des champs individuels. Si vous avez eu:

typedef struct
{
    uint8_t *field;
} foo;

volatile foo f;

Qui pourrait agir comme:

typedef struct
{
    uint8_t * volatile field;
} foo;

et pas comme:

typedef struct
{
    volatile uint8_t *field;
} foo;

Answer 2

si vous déclarez une structure volatile, tous ses membres le seront également