When would I use const volatile, register volatile, static volatile in C++?
c++, constants, static, volatile
Solution
register volatile int T=10;
`volatile` qualifier means that the compiler cannot apply optimizations or reorder access to `T`, While `register` is a hint to the compiler that `T` will be heavily used. If address of `T` is taken, the hint is simply ignored by the compiler. Note that `register` is deprecated but still used.
Practical Usage:
I have never used it never felt the need for it and can't really think of any right now.
const volatile int T=10;
`const` qualifier means that the `T` cannot be modified through code. If you attempt to do so the compiler will provide a diagnostic. `volatile` still means the same as in case 1. The compiler cannot optimize or reorder access to `T`.
Practical Usage:
- Accessing shared memory in read-only mode.
- Accessing hardware registers in read-only mode.
static volatile int T=10;
`static` storage qualifier gives `T` static storage duration (C++11 §3.7) and internal linkage, while `volatile` still governs the optimization and reordering.
Practical Usage:
- Same as `volatile` except that you need the object to have static storage duration and to be inaccessible from other translation units.
Problem
I am wondering about the different uses of the volatile keyword in combination with register, const and static keywords. I am not sure what are the effects, so I think: ``` register volatile int T=10; ``` Suggest the compiler to store T in a register and the value of T can be modified from somewhere outside (OS, hardware, another thread) ``` const volatile int T=10; ``` The program itself can not modify T, but T can be modified frow somewhere outside the code. ``` static volatile int T=10; ``` If T is a data member of a class it means that all the objects of the class have the same value for T and T can be modified from somewhere outside. If T is a global variable in a file, the source code in other files (that are part of the project) cannot access T, but T can be accessed from somewhere outside. If T is a local variable in a function,once it has been initialized remains in the memory until the end of the program and can be modified from somewhere outside. Are my thoughts correct and can any experienced C++ developer give an example where the above maybe used in real-world applications or it is very rare?