In C, how do you declare the members of a structure as volatile?

Question

How do you declare a particular member of a struct as volatile?

Answer 1

Exactly the same as non-struct fields:

#include <stdio.h>
int main (int c, char *v[]) {
    struct _a {
        int a1;
        volatile int a2;
        int a3;
    } a;
    a.a1 = 1;
    a.a2 = 2;
    a.a3 = 3;
    return 0;
}

You can mark the entire struct as volatile by using "volatile struct _a {...}" but the method above is for individual fields.

Answer 2

Should be pretty straight forward according to this article:

Finally, if you apply volatile to a struct or union, the entire contents of the struct/union are volatile. If you don't want this behavior, you can apply the volatile qualifier to the individual members of the struct/union.

Answer 3

I need to clarify volatile for C/C++ because there was a wrong answer here. I've been programming microcontroleurs since 1994 where this keyword is very useful and needed often.

volatile will never break your code, it is never risky to use it. The keyword will basically make sure the variable is not optimized by the compiler. The worst that shold happen if you overuse this keyword is that your program will be a bit bigger and slower.

Here is when you NEED this keyword for a variable : - You have a variable that is written to inside an interrupt function. AND - This same variable is read or written to outside interrupt functions. OR If you have 2 interrupt functions of different priority that use the variable, then you should also use 'volatile'.

Otherwise, the keyword is not needed.

As for hardware registers, they should be treated as volatile even without the keyword if you don't do weird stuff in your program.

Answer 4

I just finished a data structure in which it was obvious where the volatile qualifier was required, but for a different reason than the ones stated above: It is simply because the struct requires a forceful locking mechanism because of (i) direct access and (ii) equivalent invocation.

---

Direct access deals with sustained RAM reading and writing.

Equivalent invocation deals with interchangeable method flows.

---

I haven't had much luck with this keyword unless the compiler knows exactly what to do about it. And that's my own personal experience. But I am interested in studying how it directly impacts a cross-platform compilation such as between a low-level system call and a back-end database.